For getting post recieve hooks working, you have to grant github read access to your jenkins installation.

Either with granting read permissions to Anonymous or with creating a new user and giving this user read permission.

With Anonymous, the URL to configure on github is shown on the jenkins config page (Read the help entry behind the question mark):

http://www.example.com:8080/jenkins/github-webhook/

With an extra user, you have to expose the password to github, because the password is used in the URL:

http://user:password@www.example.com:8080/jenkins/github-webhook/

Eigentlich ganz geschickt, wenn man am PC surft und sich die Seite mal auf dem Smartphone anschauen möchte. Das spart doch einiges an Touchscreen-Tipperei. Einfach mit einer entsprechenden Scanner-App den QR-Code einlesen und schon steht die URL auf dem Smartphone zur Verfügung. Wenn man die App dann noch so einstellt, dass nicht automatisch eine Aktion je nach gescanntem Inhalt gestartet wird, ist das Risiko eines Hackerangriffs auch nicht gegeben.

Soweit, so gut.

Aber was ist, wenn ich z.B. ein Stück Text kopieren möchte, oder eine URL, die nicht als Link gerendert ist?

Dazu hab ich mir folgendes Bookmarklet gebastelt:

javascript:window.open('about:blank','_blank','width=480,height=100,menubar=no,toolbar=no,status=no,location=yes').document.location='http://chart.apis.google.com/chart?cht=qr&chs=480x480&chl='+window.getSelection();void(0);

Einfach den gewünschten Text auf der Webseite markieren und das Bookmarklet anklicken.

Ein Bookmarklet ist ein Bookmark, das keine URL öffnet, sondern statt dessen ein bißchen Javascript ausführt. Ein neues Lesezeichen/Bookmark im Browser anlegen und anstelle der URL den Javascript-Code einfügen – schon ist ein Bookmarklet erstellt.

Singleton oder nicht?

HelloWorldBean verwendet MyReverseService

Annotation:

@javax.inject.Named
@javax.faces.bean.RequestScoped
public class HelloWorldBean
{
    private String name = "";

    @javax.inject.Inject
    private MyReverseService service;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public void setService(MyReverseService service)
    {
        this.service = service;
    }

    public String getReverseName()
    {
        return service.reverse(name);
    }
 }

public interface MyReverseService
{
    public String reverse(String name);
}

@javax.inject.Named
@javax.faces.bean.ApplicationScoped
public class MyReverseServiceImpl implements MyReverseService
{
    public String reverse(String name)
    {
        return new StringBuffer(name).reverse().toString().toLowerCase();
    }
}

ExpressionLanguage greift auf HelloWorldBean zu

<h:form id="reverseForm">
    Input: <h:inputText id="name" value="#{helloWorldBean.name}" />
    <h:commandButton id="submit" type="submit" action="spring" />
</h:form>
Reverse: <h:outputText id="reverse" value="#{helloWorldBean.reverseName}" />

Problem:

HelloWorldBean wird ein Singleton, da Spring wohl den javax.faces.bean.RequestScoped nicht unterstützt.

Lösung 1:

Eine von Spring unterstützte Annotation:

@org.springframework.context.annotation.Scope(value="request")

Lösung 2:

XML-basierte Spring-Configuration (Vorteil: es können alle Annotations gelöscht werden und somit sind alle Klassen wieder POJOs (Plain Old Java Objects):

    <bean
        id="helloWorldBean"
        class="bean.HelloWorldBean"
        scope="request">
        <property
            name="service"
            ref="myReverseServiceImpl" />
    </bean>

    <bean
        id="myReverseServiceImpl"
        class="service.impl.MyReverseServiceImpl"
        scope="singleton" />

Im letzten Teil haben wir die Festplatte partitioniert, heute wird Debian “Squeeze” mit debootstrap installiert. Debootstrap installiert ein Minimalsystem, das dann den eigenen Bedürfnissen angepasst werden kann. Dadurch kann auf dem System genau die Software installiert werden, welche benötigt wird.

Der Abstand zum letzten Artikel erklärt sich dadurch, dass ich sehr viele Versuche brauchte, um das System zum Laufen zu kriegen. Zuerst sind Fehler gekommen bei der Installation des Grub2, da irgendwelche Devices gefehlt haben. Nach etwas surfen bin ich auf die /dev/pts gestoßen, dass fehlte. Dann habe ich festgestellt, dass man Debian nicht aus einem Kubuntu heraus komplett installieren kann. Debootstrap geht zwar, aber beim der Grub2-Installation kommt es zu Fehlern, da unterschiedliche Kernel verwendet werden.

Dann habe ich das Debian Live Projekt gefunden. Mit diesen Scripts kann ein USB-Stick-Image mit dem aktuellen Debian vorbereitet werden. Mit diesem System binn ich dann weiter gekommen, habe aber dann gekämpft, den Bootloader Grub2 zu installieren. Das neue System ist gebootet, hat aber dann nicht nach der Passphrase gefragt und sich dann beschwert, die verschlüsselte Datei nicht lesen zu können. Also habe ich zwischendurch ein Net-Installation-Image direkt von Debian gezogen und auf einen Stick kopiert. Die Test-Installation verlief reibungslos auch mit Verschlüsselung.  Damit habe ich dann geschaut, welche Unterschiede die Konfigurationsdateien haben. Diese waren identisch.

Dann waren nur noch die zum Booten nötigen unverschlüsselten Datein übrig, bei denen etwas falsch laufen konnte. Hier habe ich dann heraus gefunden, dass die initrd.gz keine Module zum entschlüsseln hatte. Und das lag einfach daran, dass ich im gebootstrapten System vergessen hatte cryptsetup zu installieren.

Aber jetzt läuft es und hier ist der nächste Teil der Server-Installationsanleitung.

Mit den folgenden Befehlen wird das Binary-Image für einen USB-Stick erzeugt und auf den Stick mit der Adresse /dev/sdX kopiert. Ich habe das unter einem Kubuntu 10.10 ausgeführt.

$ sudo -s
# apt-get install live-build
# mkdir debian-image
# cd debian-image
# lh config -a amd64 -d squeeze -p xfce-desktop -b usb-hdd
# lh build
# dd if=image.bin -of=/dev/sdX

Jetzt kann das neue Live-Debian-System gebootet und eine Shell geöffnet werden. Anmerkung: Alle Befehle werden als root ausgeführt, dazu kann mit

$ sudo -s

eine Root-Shell geöffnet werden. Zuerst installieren wir debootstrap auf unserm USB-Linux:

# apt-get install debootstrap

Falls noch nicht geschehen, muss die verschlüsselte Root-Partition geöffnet werden:

# cryptsetup luksOpen /dev/sda2 crypt_root

Anschließend werden die vorbereitete Partition gemountet. Dazu wird ein Verzeichnis angelegt:

# mkdir /mnt/debinst
# mount /dev/mapper/crypt_root /mnt/debinst

Dann wird die unverschlüsselte Boot-Partition eingehängt:

# mkdir /mnt/debinst/boot
# mount /dev/sda1 /mnt/debinst/boot

Nun wird mit debootstrap das System installiert:

# debootstrap --arch amd64 squeeze /mnt/debinst http://ftp.de.debian.org/debian

Dann werden die UUIDs der Partitionen ermittel (am besten in einem zweiten Terminalfesnter, dann kann mit Copy&Paste gearbeitet werden):

# blkid /dev/sda1
# blkid /dev/sda2
# blkid /dev/sda3

Diese UUIDs werden gleich für die /etc/crypttab benötigt. Nachdem das Basissystem installiert ist, wird nun in das neue System gewechselt, vorher werden noch die Devices eingehängt :

# mount -o bind /dev /mnt/debinst/dev
# mount -t proc proc /mnt/debinst/proc
# mount -t sysfs sys /mnt/debinst/sys
# mount -t devpts devpts /mnt/debinst/dev/pts
# LANG=C chroot /mnt/debinst /bin/bash

Als erstes sollte das Passwort für den User root gesetzt werden:

# passwd
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully

Die /etc/crypttab wird mit den folgendem Inhalt angelegt (die UUIDs wurden oben mit blkid ermittelt):

crypt_root UUID=<SDA2_ROOT_VOLUME_ID> none luks
crypt_swap UUID=<SDA3_SWAP_VOLUME_ID> crypt_root luks,swap,keyscript=/lib/cryptsetup/scripts/decrypt_derived

Auf diese Angaben kann sich dann die anzulegende Datei /etc/fstab beziehen, die mit folgendem Inhalt erzeugt wird:

# /etc/fstab: static file system information.
#
# file system           mount point  type  options            dump  pass
proc                    /proc        proc  defaults           0     0
/dev/mapper/crypt_root  /            ext3  errors=remount-ro  0     1
UUID=<SDA1_BOOT_VOLUME_ID>  /boot    ext3  defaults           0     2
/dev/mapper/crypt_swap  none         swap  sw                 0     0

Nun wird /etc/network/interfaces angepasst. Die Datei sollte dann wie folgt aussehen:

# Used by ifup(8) and ifdown(8). See the interfaces(5) manpage or
# /usr/share/doc/ifupdown/examples for more information.

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

Der Name des Servers kann auch noch angepasst werden:

# echo DebianHostName > /etc/hostname

Für die weitere Installation werden die Quellen für apt-get erweitert:

# vi /etc/apt/sources.list

Inhalt:

deb http://ftp.de.debian.org/debian squeeze main
deb http://ftp.de.debian.org/debian squeeze contrib
deb http://ftp.de.debian.org/debian squeeze non-free
deb http://security.debian.org/ squeeze/updates main
deb-src http://ftp.de.debian.org/debian squeeze main
deb-src http://ftp.de.debian.org/debian squeeze contrib
deb-src http://ftp.de.debian.org/debian squeeze non-free
deb-src http://security.debian.org/ squeeze/updates main

Mit

# apt-get update

werden die neuen Quellen eingelesen. Die Timezone (Europe/Berlin) wird mit folgendem Kommando eingestellt:

# dpkg-reconfigure tzdata
Europe
Berlin

Nun werden lokale Einstellungen (locales) und Tastaturlayout konfiguriert:

# apt-get install locales
# dpkg-reconfigure locales
de_DE.UTf-8 UTF-8
en_US.UTF-8 UTF-8
default: en_US.UTF-8

# apt-get install console-data
Select keymap from arch list
qwertz
German
Other
Germany
Germany - eleminate dead keys
. Combined - Latin; Slavic Cyrillic; Greek
# dpkg-reconfigure console-data
Select keymap from arch list
qwertz
German
Standard
latin1 - no dead keys

Nun noch die mounts in die mtab eintragen. Dazu einen Symlink erstellen:

# ln -sf /proc/mounts /etc/mtab

Jetzt wird der passende Kernel installiert. Mit dem Befehl

# apt-cache search linux-image

wird eine Liste mit Kernel-Images angezeigt und dann kann der passende Kernel installiert werden:

# apt-get install linux-image-amd64

Anschließend wird cryptsetup und der Bootloader GRUB2 installiert und eingerichtet:

# apt-get install cryptsetup
# apt-get install grub-pc
Linux command line leer lassen
/dev/sda wählen
# update-initramfs -u -k all

Nun werden weitere Packete installiert, die auf einem Server nützlich sind:

# apt-get install ssh
# apt-get install vim
# apt-get install less

Zum Schluss kann nun der Rechner neu gestartet und von der Festplatte gebootet werden. Beim Booten wird die Passphrase abgefragt. Nach Eingabe der Passphrase wird das System gestartet und man landet in der Konsole mit dem Login-Prompt.

Voraussetzungen

• Installiertes Eclipse Helios JEE
• Installierter Apache Tomcat 7
• Installiertes Plugin m2eclipse

Info 2011-05-21: m2eclipse 0.12 und Eclipse Helios arbeiten nicht so wirklich zusammen. Es gibt Probleme beim Download der Repository-Indizes. Deswegen sollte ein Milestone-Release von m2eclipse 0.13 von der Eclipse-Homepage (http://www.eclipse.org/m2e/) verwendet werden!

Die Eclipse JEE Edition bringt die Web Tools Platform mit. Diese Plugins unterstützen die Entwicklung von JavaEE  Anwendungen. Für Web Applikation gibt es verschiedene Konfigurationen, die unterschiedliche Features “freischalten”. Bei Verwendung der JavaServer Faces Konfiguration gibt es z.B. einen speziellen Editor, mit dem die XML-Datei der JSF-Konfiguration bearbeitet werden kann. Außerdem können verschiedene Target Runtimes angelegt werden. Dadurch werden automatisch die Bibliotheken dieser Laufzeitumgebung im Classpath des Projektes aufgenommen.

Projekt anlegen

In Eclipse wird in der Java EE Perspektive ein neues “Dynamic Web Project” mit den folgenden Einstellungen angelegt.

Seite 1 (Dynamic Web Project): Auf der ersten Seite werden die grundlegenden Einstellungen vorgenommen. Neben Name und Speicherort wird hier eingestellt, für welche Zielumgebung die Web Applikation entwickelt wird. Die Version des Web Modul bestimmt, welche JEE Spezifikationen verwendet werden können. Die Konfiguration bestimmt, welche Features zusätzlich aktiviert werden. Als letztes kann noch angegeben werden, ob das Projekt Teil einer Enterprise Application (EAR) werden soll.

• Target runtime: Apache Tomcat v7.0
• Dynamic web module version: 3.0
• Configuration: JavaServer Faces v2.0 Project

Für dieses Projekt verwenden wir eine aktuelle Version von Tomcat 7, Version 3.0 des Web Module, da erst diese Version JSF 2.0 unterstützt.

Seite 2 (Java): Im zweiten Schritt werden die Verzeichnisse für die Java-Sourcen und die kompilierten Klassen festgelegt.

• Source folders on build path: src entfernen, src/main/java anlegen
• Default output folder: target/classes eintragen

Da wir Maven verwenden wollen, werden die Verzeichnisse entsprechend dem offiziellen Standard-Layout angepasst.

Seite 3 (Web Module): Die Daten für die Web Applikation werden auf Seite drei eingegeben. Der Context root wird beim Ausführen in Eclipse verwendet. Im Content directory liegen alle Dateien der Website (Seiten, Bilder, CSS, usw.) und die Konfigurationsdateien, z.B. die web.xml. Diese kann auch gleich mit den benötigten Einträgen erstellt werden.

• Content directory: src/main/webapp
• Generate web.xml deployment descriptor: aktivieren

Für unser Projekt passen wir das Verzeichnis ebenfalls dem Maven Standard an und lassen den Deployment Descriptor gleich mit den Einträgen für JSF erstellen. Angepasst wird er später.

Seite 4 (JSF Capabilities): Zum Schluss werden die benötigen Angaben zu den JavaServer Faces abgefragt. Mit der JSF Implementation Library wird WTP mitgeteilt, wo die JSF-jars liegen. Außerdem wird die JSF-Konfiguration festgelegt.

• Type: Disable Library Configuration
• URL Mapping Patterns: /faces/* entfernen, *.xhtml hinzufügen

Da wir Maven verwenden, deaktivieren wir die JSF-Bibliotheken. Diese kommen später als Dependencies hinzu. Da wir Facelets verwenden werden, stellen wir das Mapping um. Das ist aber nicht zwingend nötig und könnte auch unverändert übernommen werden.

Maven aktivieren

Das m2eclipse-Plugin übernimmt die Verwaltung des Classpath’ in Eclipse. Alle Dependencies werden automatisch aufgenommen, sobald die pom.xml geändert wird. Außerdem bringt es noch eine Erweiterung für WTP mit, so dass im Projekt-Explorer ein zusätzlicher Eintrag im Baum (“Web Resources” ) erscheint.

Rechtsklick auf das Projekt und Maven/Enable Dependency Management auswählen

Seite 1 (Maven2 POM): Auf der ersten Seite werden die allgemeinen Mavendaten des Projekts erfasst. Group Id und Artifact Id dienen der eindeutigen Identifizierung des Produkts. Versionsnummern mit “-SNAPSHOT” kennzeichnen Projekte in der Entwicklung. Beim Deploy in ein MAven Repository wird die Endung durch den aktuellen Timestamp ersetzt. Packaging gibt an, wie das Produkt verpackt werden soll (jar, war, …). Name und Description liefern den Anwendern nährere Infos zum Produkt.

• Group Id anpassen (net.bohni.sample)
• Artifact Id anpassen (sample-war)
• Packaging: war

Für unser Beispiel passen wir Group und Artifact Id an und setzten Packaging auf “war”, da wir eine Web Applikation erstellen werden.

Seite 2 (Select additional dependencies): Die Abhängigkeiten werden auf der zweite Seite erfasst.

• org.slf4j slf4j-api 1.6.1
• ch.qos.logback logback-classic 0.9.26

Da die aktuellen JSF Bibliotheken nicht im offiziellen Maven Repository sind, können wir an dieser Stelle die jars noch nicht hinzufügen. Dazu erweitern wir später den POM um das passende Repository von java.net. An dieser Stelle fügen wir die Bibliotheken fürs logging hinzu.

Projekt konfgurieren

Durch das Aktivieren von Maven gibt es nun Fehler im Projekt. Zum einen wird eine falsche JRE System Library im build Path gesetzt, zum anderen müssen die Maven Dependencies aufgenommen werden, damit diese später auch in WEB-INF/lib landen. Um diese Fehler zu beheben werden die Properties des Projekts geöffnet und folgende Einstellungen geändert:

• Java Build Path: Libraries: JRE System Library [...] ->JRE System Library [JavaSE-1.6]
• Deployment Assembly: Hinzufügen von Java Build Path Entries/Maven Dependencies

Maven verwendet standardmäßig Java 1.4, deswegen muss noch das Compiler-Plugin konfiguriert werden, das geschieht in der Datei pom.xml. Es ist folgender Abschnitt einzufügen:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.3.2</version>
      <configuration>
        <source>1.6</source>
        <target>1.6</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Anschließend muss das java.net Maven2 Repository im pom.xml aufgenommen werden, damit die aktuelle JavaServer Faces Version als Dependency aufgenommen werden kann. Entweder mit dem POM-Editor ein neues Repository anlegen, oder im Source die folgenden Zeilen einfügen:

<repositories>
  <repository>
    <id>maven2-repository.dev.java.net</id>
    <name>Java.net Repository for Maven</name>
    <url>http://download.java.net/maven/2/</url>
    <layout>default</layout>
  </repository>
</repositories>

Nun können die aktuellen JSF-Bibliotheken als Dependencies hinzugefügt werden (im POM-Editor oder über Rechtsklick auf Projekt/Maven/Add Dependency:

• javax.facers jsf-api 2.0
• com.sun.faces jsf-impl 2.0.3

Webapplikation erstellen

Unsere Wep Applikation wird eine einfache Hello World Anwendung. Es gibt eine Seite, auf der ein String angezeigt wird, welcher aus einer ManagedBean kommt.

Managed Bean

Dazu erzeugen wir die ManagedBean, indem wir mit dem Faces-Config-Editor die Bean in der faces-config.xml eintragen (da der auszugebende String nur auf der einen Seite zur Anzeige benötigt wird, gibt es eine Bean mit dem Scope request):

Seite 1 (Java Class Selection): Hier kann gewählt werden, ob die ManagedBean eine bestehende oder eine neue Klasse ist.

• Create a new Java class

Wir haben noch keine Klasse, also legen wir eine neue an.

Seite 2 (Java Class): Hier wird mit dem Standarddialog aus Eclipse die Klasse angelegt.

• Package angeben (net.bohni.sample.beans)
• Name angeben (MyBean)

Wir benötigen eine ganz normale public POJO-Klasse. Also passen wir nur package und Name an. Supperclass und Interfaces werden nicht benötigt.

Seite 3 (Managed Bean Configuration): Auf der vorletzten Seite wird der Name und der Scope, sowie eine Beschreibung angegeben.

• Name angeben (myBean)
• Scope auswählen (request)

Für unser Beispiel übernehmen wir die vorgeschlagenen Werte.

Seite 4 (Wizard Summarys): Die letzte Seite zeigt noch einmal die Angaben. Mit Klick auf Finish wird der Klassenrumpf erzeugt.

Anschließend programmieren wir die benötigte Methode, die den String liefert.

package net.bohni.sample.bean;

public class MyBean
{
  public String getName()
  {
    return "Hello world";
  }
}

HTML-Seite

Neue HTML-Datei /src/main/webapp/index.xhtml erstellen

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <title>Homepage</title>
</head>
<body>
  <h1>Homepage</h1>
  <p>Hier geht es los...</p>
  <p>#{myBean.name}</p>
</body>
</html>

Deployment Descriptor web.xml

Zum Schluss passen wir noch die welcome-file-list im Deployment Descriptor src/main/webapp/WEB-INF/web.xml an:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>sample-war</display-name>
  <welcome-file-list>
    <welcome-file>index.xhtml</welcome-file>
  </welcome-file-list>
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
</web-app>

Als Ergänzung zum letzten Blogeintrag hier noch die Liste der verbauten Hardware:

• CPU: Intel Core i3-350
• CPU-Lüfter: Scythe Samurai ZZ
• Mainboard: MSI H55M-E33
• Speicher: 2x2GB (DDR3-1333/PC3-10600, CL9)
• Festplatte: Samsung EcoGreen F2 1,5TB, SATA II
• DVD-Brenner: LG GSA-4182
• Gehäuse: Antec Sonata II
• Netzteil: be quiet! Pure Power 300 Watt / BQT L

Das Betriebssytem

Wie die Titel der Blogbeiträge schon andeuten, soll auf dem Server die aktuelle Version “Lenny” der Linux-Distribution Debian installiert werden. Dazu möchte ich aber nicht den Weg über den Debian-Installer gehen, sondern das System so klein wie möglich aufsetzen. Dazu bietet sich die Installation mittels debootstrap an.

Dazu boote ich das System von USB-Stick mit der aktuellen Kubuntu-Version 10.10 “Maverick Meerkat”. Den USB-Stick (4GB) habe ich mit Linux Live USB Creator erzeugt. Damit nicht alle Einstellungen verloren gehen, habe ich den verbleibenden Platz des Sticks für permanenten Speicher vergeben.

Die Festplatte vorbereiten

Als erstes wird nun die frisch verbaute Festplatte geprüft. Dazu kommt das Tool badblocks zum Einsatz.

Anmerkung: Alle Befehle werden als root ausgeführt, dazu kann mit

$ sudo -s

eine Root-Shell geöffnet werden. Mit dem Befehl

# badblocks -c 1024 -s -w -t random -v /dev/sda

wird die komplette Platte (da in meinem System nur eine SATA-Festplatte verbaut ist, ist das dev/sda) mit zufälligen Werten überschrieben und gleich noch geprüft. Das dauert einige Stunden bei 1,5 TB… Das ist übrigens auch zu empfehlen, wenn man eine alte Platte entsorgen möchte. Danach sind nämlich alle Daten weg. Also aufpassen, damit nicht das falsche Device gelöscht wird!

Während badblocks also so vor sich hin prüft, werden wir uns nun mit der anstehenden Partitionierung der Platte beschäftigen. Da ich die Platte verschlüsseln möchte, benötigen wir auf jeden Fall eine kleine Boot-Partition, die später unverschlüsselt ist, damit Linux überhaupt bootet. Dann benötigen wir natürlich die unter Linux übliche Swap-Partition. Der Rest bleibt dann für die verschlüsselte Root-Partition übrig.

Zum Partitionieren habe ich mich für die grafische Variante mittels KDE-Partitionmanager entschieden. Dazu muss allerdings das Softwarepaket erst noch installiert werden. Das geschieht über die Softwareverwaltung KPackageKit. Hier müssen dann zuerst in den Einstellungen alle Quellen aktiviert werden, damit auch Pakete aus den Repositories universe und multiverse installiert werden können.

Wenn badblocks fertig ist, bereiten wir die Partitionen vor. Als Dateisystem verwenden ich ext3, da dieses von den meisten Festplattentools sehr gut unterstützt wird.

Ich habe dann die Boot-Partition mit 200MiB am Anfang der Platte erzeugt, danach die große Root-Partition, indem ich am Ende 5200MiB Platz (RAM + 30%) gelassen habe. Zum Schluss habe ich im verbleibenden Teil der Platte die Swap-Partition angelegt.

Es ergibt sich damit die folgende Aufteilung der Festplatte (da die Platte in Sektoren aufgeteilt wird, weichen die tatsächlichen Partitionsgrößen etwas von den eingegebenen Werten ab). Mit dem Befehl

# cfdisk /dev/sda

kann die Aufteilung angezeigt werden:

 Name    Flags    Part Type  FS Type                 Size (MB)
------------------------------------------------------------------------------
 sda1             Primary    Linux                      197.41
 sda2    Boot     Primary    Linux                  1494903.52
 sda3             Primary    Linux swap / Solaris      5198.38

Zum Schluss bereiten wir nun noch die Partitionen vor. Die kleine unverschlüsselte Boot-Partition formatieren wir dazu mit dem Befehl:

# mkfs.ext3 /dev/sda1

Danach ist die zu verschlüsselnde Partition dran: Zuerst wird das LUKS-Gerät erzeugt, was mit dem Befehl

# cryptsetup -c aes-xts-plain -s 512 luksFormat /dev/sda2

passiert. Mit einem groß geschriebenen yes wird der Befehl bestätigt. Dann muss noch zweimal die Passphrase eingegeben werden, um einen Tippfehler zu verhindern. Anschließend wird das gerade erzeugte Gerät noch geöffnet, damit es formatiert werden kann. Das geschieht mit den beiden folgenden Befehlen (der erste Befehl fragt nach der Passphrase und bindet dann die Partition unter /dev/mapper/crypt_root ein):

# cryptsetup luksOpen /dev/sda2 crypt_root
# mkfs.ext3 /dev/mapper/crypt_root

Zuletzt wird noch die ebenfalls zu verschlüsselnde Swap-Partition vorbereitet. Dazu leiten wir einen Schlüssel von unserer Root-Partition ab:

# /lib/cryptsetup/scripts/decrypt_derived crypt_root \
   | cryptsetup -c aes-xts-plain -s 512 luksFormat /dev/sda3
# /lib/cryptsetup/scripts/decrypt_derived crypt_root \
   | cryptsetup luksOpen /dev/sda3 crypt_swap
# mkswap /dev/mapper/crypt_swap

Der foglende Befehl schließt die verschlüsselten Partitionen wieder:

# cryptsetup luksClose crypt_root
# cryptsetup luksClose crypt_swap

Somit sind alle drei Partitionen vorbereitet. Im nächsten Teil wird dann das Minimalsystem installiert.

Lange habe ich auch deswegen gezögert, weil ich mir nicht über die Hardware schlüssig war. Meine ausgedienten Spiele-PCs waren bzw. sind eigentlich viel zu überdimensioniert. Sie brauchen viel zu viel Strom, auch wenn sie nur im Leerlauf vor sich hin brummen. Außerdem benötigt so ein SpielePC auch gute Lüfter, die die anfallende Wärme aus dem Gehäuse bläst, was leider auch mit einer entsprechenden Geräuschkulisse einher geht.

Aber dann kam der Artikel “Wünsch dir was zum Arbeiten” in der c’t 08/2010. Hier wird ein Bauvorschlag für einen PC zum Arbeiten vorgestellt, der “in erster Linie unauffällig seinen Dienst” tun soll. Ein PC, der “zum Arbeiten, Surfen oder Bildanhübschen” reicht, sollte doch locker auch als Server herhalten können. Und da neben den flüsterleisen Komponenten auch noch auf den Stromverbrauch geachtet wurde, habe ich mich vor ein paar Wochen dazu entschieden, diesen Bauvorschlag nachzubauen.

Von meinem alten Spiele-PC hatte ich noch ein Silent-Gehäuse Antec Sonata II übrig. Das Sonata II ist bereits mit einem Netzteil ausgestattet. Also habe ich mir die noch fehlenden Komponenten (CPU, Mainboard, Hauptspeicher, Festplatte und CPU-Kühler) gekauft. Den DVD-Brenner habe ich ebenfalls aus dem alten PC übrnommen,  Antivibrationsrahmen für die Festplatte sind beim Sonata dabei.

Nachdem alles bereit lag, habe ich den Rechner zusammengebaut. Das hat problemlos geklappt, denn es war nicht der erste PC, den ich selbst gebaut habe. Allerdings bin ich trotzdem auf Probleme gestoßen.

Das erste Problem war der Hauptspeicher. Da im Bauvorschlag keine Angaben zum Hersteller gemacht wurden, habe ich den Speicher hauptsächlich nach Preis gekauft. Das böse erwachen kam dann beim ersten Einschalten. Der Rechner kam nicht einmal bis zum BIOS. Kein Pieps, einfach nichts. Nur die Festplatte ist angelaufen und hat in regelmäßigen Abständen kurz geklickt, wie bei einem Lesezugriff. Ich hab dann zuerst Mal alle nicht notwendigen Geräte ausgesteckt (Festplatte, DVD-Brenner) und einen Speicherriegel entfernt. Und siehe da, nun ist das BIOS nach dem Einschalten tatsächlich aufgetaucht. Dann hab ich den zweiten Riegel eingesteckt und schon blieb der Bildschirm dunkel. Dann hab ich den zweiten Riegel in einen anderen Steckplatz umgezogen (nun ohne Dual-Channel) und das BIOS war wieder da. Es gab also den ersten Anhaltspunkt: Dual-Channel. Also habe ich nach einem neuen BIOS gesucht und auch eines gefunden, aber das Problem blieb bestehen. Somit war der Übeltäter entlarvt. Der Speicher! Nach etwas Internet-Forschung bin ich dann auf die Kombatibilitätsliste des Mainboards gestoßen, was den Speicher angeht. Aha, der bestellte Speicher war nicht dabei. Gleiche Firma, aber etwas andere Nummer. Also hab ich den Speicher zurück geschickt und mir kompatiblen Speicher geholt. Leider mit dem gleichen Ergebnis – im Dual-Channel-Betrieb geht nichts. Da de Dual-Channel-Mode aber sowieso nicht so viel Leistungsteigerung bringt, habe ich beschlossen, das System ohne zu betreiben, denn auf noch mehr zurückschicken und neu bestellen hatte ich keine Lust.

Die nun laufende Hardware wollte ich nun das erste Mal mit Software sehen. Also habe ich ein Kubuntu-CD-Image auf einen USB-Stick kopiert und davon gebootet. Das brachte mich zum zweiten Problem. Der Stromverbrauch! Anstelle der im Artikel erwähnten “weniger als 30 Watt Leistungsaufnahme im Leerlauf” kam mein System auf mehr als das doppelte: 62 Watt! Eine Recherche im Internet ergab, dass Linux etwas mehr benötigt als Windows, aber über das Doppelte?! Also habe ich Windows 7 installiert und festgestellt, dass Windows tatsächlich weniger Strom braucht, 0,5 bis 2 Watt weniger… Daran lag es also nicht. Auch die neuesten Treiber haben keine Besserung gebracht. Also habe ich mich entschlossen, doch noch das (günstigere) Netzteil aus dem Artikel zu bestellen. Und siehe da, jetzt sind es unter Windows plötzlich nur noch 33 Watt! Da ich 2 DVD-Laufwerke angeschlossen habe, denke ich, ist das OK. Unter Linux erreiche ich 35 Watt.

Somit habe ich nun das Kapitel Hardware erledigt. Der Rechner ist wirklich leise – unhörbar leise. Ich hab nicht damit gerechnet, dass Rechner tatsächlich so leise sein können! Nur wenn ich ganz nahe mit dem Ohr ans Gehäuse gehe, dann höre ich ganz leise die Festplatte. Und die Stromkosten für durchgängig 35 Watt Verbrauch sind vertretbar.

Momentan muss ich bei jedem Rechnerwechsel daran denken, alle meine Daten zu sichern. Genauso ist es bei einem Wechsel des Betriebssysstems (Windows 95, windows 98, Windows ME, Windows XP, Windows Vista). Und gerade unter Windows ist das nicht unbedingt einfach. Neben dem Benutzer-Verzeichnis gibt es ja noch diverse andere Stellen, wo sich so im Laufe der Zeit die Daten sammeln. Ganz zu schweigen von den diversen persönlichen Einstellungen der Programme und der Registry.

Irgendwann hab ich dann angefangen, zumindest meine wichtigen Daten auf eine eigene Partition zu speichern, so dass nichts in den tiefen der Windows-Chaos-Verzeichnisstruktur verloren geht. Gerade bei den E-Mails und Browsereinstellungen war es hilfreich, auf die Mozilla-Programme (Firefox, Thunderbird) umzusteigen. Hier kann beim Anlegen eines Profils der Pfad zu einem bestehenden Profil angegeben werden und schon ist alles so, wie vor dem Umzug. Also hab ich die beiden Profile auch auf der zweiten Partition angelegt.

Aber in der heutigen Zeit möchte man ja seine Daten nicht nur am Desktop-PC, sondern auch auf dem Note- oder Netbook, vielleicht sogar auf dem Smartphone haben.

Die Idee

Nun gut, es ist nicht meine eigene Idee, vielmehr muss ich mich bei meinem Freund Matze bedanken, der schon seit Jahren einen eigenen Server betreibt. Das ganze ist Debian basiert, eine stabile, zuverlässige Linux-Distribution.

Also habe ich mich vor langer Zeit schon entschlossen, mir auch so einen Server zuzulegen. Aber immer kam irgendwie der innere Schweinehund vorbei und wollte spielen (Command & Conquer, Starcraft, World of Warcraft, Herr der Ringe Online, …). So blieb dann keine Zeit übrig, sich um den Serveraufbau zu kümmern. Aber jetzt soll es endlich losgehen.

Warum der Server? Nun, damit kann ich alle meine E-Mails von den unterschiedlichen Providern regelmäßig abholen und dann per IMAP auf allen meinen Endgeräten anschauen. Auch meine ganzen Daten (Dokumente, Fotos, Entwicklungsprojekte, usw.) kann ich hier speichern und dann von überall darauf zugreifen.

In diesem Blog möchte ich nun meine Erfahrungen teilen, die ich in nächster Zeit beim Aufbau des Servers so sammle.

Wie ihr seht, gibt es noch nicht viel zu sehen. Ich hoffe ja mal, dass ich es schaffe, auch mal sinnvolle Beiträge zu schreiben!

Bis dahin bleibt mir nur zu sagen: Danke für’s vorbei schauen und Entschuldigung für den Zeitklau, weil es noch nichts zu lesen gibt!

Mal sehen, ob ich genügend Zeit, Lust und Themen finde, dieses Blog zu füllen.

Die Zukunft wird es zeigen.