Herunterladen und Entpacken des ISO-Images¶

Zunächst lädt man sich das Image auf Ryan Finnies Blog 🇬🇧 ⮷ oder auf der Wiki-Seite von Ubuntu.com 🇬🇧 herunter, welches später auf die microSD-Karte gespielt wird. Optional, aber empfehlenswert ist die Prüfung der PGP-Signatur. Im Anschluss wird das Image entpackt und man erhält die Dateien 2015-03-02-ubuntu-trusty.img und 2015-03-02-ubuntu-trusty.bmap.

Image auf microSD-Karte übertragen¶

Der Vorgang ist z.B. auf dem 321linux-Blog 🇩🇪 oder auf raspberrypi.org 🇬🇧 sehr ausführlich beschrieben und ist nach dieser Anleitung durchzuführen.

Kurz zusammengefasst wird der Befehl dd verwendet, um das Image auf die microSD-Karte zu schreiben. Dieser Vorgang kann vor allem bei größeren microSD-Karten sehr lange dauern:

dd bs=4M if=/Pfad/zum/Image/yyyy-mm-dd-ubuntu-trusty.img of=/dev/sdx bs=1M 

Ext4-Partition vergrößern¶

Nachdem das Image auf die microSD-Karte übertragen ist, befindet sich dort eine kleine Ext4-Partition. Diese muss nun vergrößert werden, damit später genügend Platz für die Installation der grafischen Oberfläche vorhanden ist. Am einfachsten ist dies mit GParted zu realisieren. Falls keine weiteren Partitionen auf der microSD-Karte benötigt werden, kann die Ext4-Partition auf den gesamten verfügbaren Platz vergrößert werden.

System starten¶

Nachdem das Image auf die microSD-Karte geschoben und die Ext4-Partition entsprechend vergrößert wurde, kann man die microSD-Karte in den Raspberry Pi einlegen und den Pi starten. Hierzu gibt es keinen Schalter. Der Start erfolgt, sobald man dem Pi Strom zuführt.

Nun kann man sich auf den Pi anmelden:

• Benutzername: ubuntu

• Passwort: ubuntu

Locale-Einstellungen anpassen¶

Für die Benutzung des Englischen Desktops mit deutscher Tastaturbelegung sollte zunächst folgende Befehle ausgeführt werden.

sudo locale-gen en_US.UTF-8
sudo locale-gen de_DE.UTF-8
sudo dpkg-reconfigure keyboard-configuration 

System Updaten und Desktop installieren¶

Nach einem Update mittels

sudo apt-get update
sudo apt-get dist-upgrade 

kann man sich je nach Wunsch eine grafische Oberfläche installieren. Dieser Vorgang kann einige Zeit in Anspruch nehmen. Für die Installation gibt man im Terminal folgendes ein:

• Für LXDE:

  sudo apt-get install lubuntu-desktop 

• Für Xfce:

  sudo apt-get install xubuntu-desktop 

• Für KDE (aus Gründen der Performance nicht empfohlen):

  sudo apt-get install kubuntu-desktop 

Nach der Installation kann der Pi mit dem Befehl:

sudo shutdown -r now 

neu gestartet. Nach dem erneuten Hochfahren kann man sich wie gewohnt an der Benutzeroberfläche anmelden.

Zusätzlichen Grafiktreiber installieren¶

Mit fbturbo 🇬🇧 ist ein beschleunigter Grafiktreiber X.org 🇬🇧 für den Pi verfügbar, den man installieren und nutzen sollte. Die Installation erfolgt mit:

sudo apt-get install xserver-xorg-video-fbturbo 

Im Anschluss muss man eine xorg.conf erstellen und so konfigurieren, dass der Treiber auch verwendet wird. Dazu installiert man beispielsweise den Editor Nano:

sudo apt-get install nano 

und öffnet die /etc/X11/xorg.conf. (Zu diesem Zeitpunkt existiert die Datei noch nicht. Sie wird jedoch erzeugt, sobald man sie wie unten beschrieben abspeichert)

sudo nano /etc/X11/xorg.conf  

Nun fügt man die folgenden Zeilen in die Datei ein und speichert sie mit der Tastenkombination Strg + X . Die Rückfrage wird nochmals mit Y + ⏎ bestätigt.

Section "Device"
    Identifier "Raspberry Pi FBDEV"
    Driver "fbturbo"
    Option "fbdev" "/dev/fb0"
    Option "SwapbuffersWait" "true"
EndSection

Um zu prüfen, ob der Treiber auch verwendet wird, sucht man nach einem Neustart in der Datei /var/log/Xorg.0.log nach dem Eintrag.

(II) FBTURBO(0): processor: ARM Cortex-A7

Ist dieser vorhanden, wird der Treiber verwendet.

Im Anschluss sind noch ein paar Raspberry-Pi spezifische Programme zu installieren und Links zu setzten. Details dazu finden sich auf der Download-Seite des Images 🇬🇧

sudo apt-get install libraspberrypi-bin libraspberrypi-dev
sudo ln -s /usr /opt/vc
sudo apt-get install libraspberrypi-bin-nonfree 

Nach einem zweiten Neustart ist der Pi fertig aufgesetzt und kann benutzt werden. Wer den Raspberry Pi von einem anderen Rechner aus steuern will, findet weiter unten auf dieser Seite 🇩🇪 noch gute Hinweise dazu.

Swap-Datei erzeugen¶

Nach der Installation besitzt das System keinen Auslagerungsspeicher. Dieser kann optional z.B. mit dem Befehl dphys 🇬🇧 als Datei angelegt werden. Zu beachten ist, dass bei der Installation von dphys automatisch eine Swap-Datei im Verzeichnis /var erzeugt wird, die die doppelte Größe des verfügbaren RAM-Speichers besitzt. Im Falle des Raspberry Pi Modell B also etwa 2 GiB. Man sollte sich zuvor vergewissern, dass ausreichend Speicherplatz auf der zuvor vergrößerten ext4-Partition vorhanden ist.

sudo apt-get install dphys-swapfile 

Vorab: Überprüfen der encryp und decrypt time¶

Bevor man eine neue jbigi-Bibliothek verwendet, sollte man auf der Seite http://localhost:7657/stats zwei Kennwerte auslesen die besagen, wie "effektiv" der Router Nachrichten ver- und entschlüsselt. Diese Werte sind crypto.elGamal.decrypt und crypto.elGamal.encrypt (in ms). Man sollte sich die beiden Werte notieren, um später überprüfen zu können, ob die gebaute jbigi auch eine Verbesserung mit sich bringt.

jbigi-Bibliothek aus dem Archiv verwenden¶

Die für verschiedene Systeme vorkonfigurierten jbigi-Bibliotheken befinden sich in der Datei ~/i2pbin/lib/jbigi.jar. Aktuell (I2P-Version 0.9.19) wird aus diesem Archiv die Datei "libjbigi-linux-armv6.so" benötigt. Die "libjbigi-linux-armv5.so" und "libjbigi-linux-armv7.so" funktionieren nicht! Man entpackt das Verzeichnis, kopiert die libjbigi-linux-armv6.so in den I2P-Installationsordner und bennent die Datei dann in libjbigi.so um.

mkdir ~/unpackedjar
mv ~/i2pbin/lib/jbigi.jar ~/unpackedjar
cd ~/unpackedjar
unzip jbigi.jar
mv libjbigi-linux-armv5.so ~/i2pbin/libjbigi.so
rmdir ~/unpackedjar 

jbigi-Bibliothek selbst bauen¶

Dafür benötigt man zunächst GMP 🇬🇧 und installiert dazu folgendes Paket aus den Paketquellen:

sudo apt-get install libgmp3-dev 

Dann lädt man sich von der Projektseite 🇬🇧 den aktuellen Source-Code von I2P (i2psource_VERSION.tar.bz2) herunter und entpackt ihn in das Home-Verzeichnis (oder abweichend falls gewünscht).

Nun wird der Source-Code entpackt und im entstandenen Verzeichnis ~/i2p-VERSION/core/c/jbigi/ nach den folgenden zwei Dateien gesucht:

• build.sh

• build_jbigi.sh

Diese öffnen man nun mit einem Editor. Den beiden Skripten muss über die Variablen I2P und JAVA_HOME mitgeteilt werden, wo der I2P-Router bzw. JDK installiert sind. Dazu fügt man die Variablen zunächst in der Datei build.sh ein:

Vorher:

#!/bin/sh
#
#  Build the jbigi library for i2p
#
#  To build a static library:
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh
#       This script downloads gmp-4.3.2.tar.bz2 to this directory
#       (if a different version, change the VER= line below)
#
#  To build a dynamic library (you must have a libgmp.so somewhere in your system)
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh dynamic
#
#  The resulting library is lib/libjbigi.so
#

rm -rf bin/local
mkdir -p lib bin/local

# Use 4.3.2 32bit CPUs.
# Use 5.0.2 64bit CPUs.
VER=4.3.2

Nachher:

#!/bin/sh
#
#  Build the jbigi library for i2p
#
#  To build a static library:
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh
#       This script downloads gmp-4.3.2.tar.bz2 to this directory
#       (if a different version, change the VER= line below)
#
#  To build a dynamic library (you must have a libgmp.so somewhere in your system)
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh dynamic
#
#  The resulting library is lib/libjbigi.so
#

I2P=/home/serverd/i2pbin
JAVA_HOME=/opt/java/jdk1.8.0_33

rm -rf bin/local
mkdir -p lib bin/local

# Use 4.3.2 32bit CPUs.
# Use 5.0.2 64bit CPUs.
VER=4.3.2

In der build_jbigi.sh geht man analog vor. Hier genügt es allerdings, die Variable „JAVA_HOME=/opt/java/jdk1.8.0_33“ zu definieren. Jetzt wechselt man im Terminal in den Ordner und führt die build.sh mit dem Attribut dynamic aus:

cd ~/i2p-VERSION/core/c/jbigi
sh build.sh dynamic 

Am Ende der Ausgabe erhält man etwa folgende Zeilen:

...
INFO: run time: 1474ms (14ms each)
INFO: 100 runs complete without any errors
native run time: 	1474ms (14ms each)
java run time:   	14989ms (148ms each)
native = 9.833878177330043% of pure java time
If the second run shows better performance, please use the jbigi that you have compiled so that I2P will work better!
(You can do that just by copying lib/libjbigi.so over the existing libjbigi.so file in $I2P)

Die angegebene „native run time“ sollte um Faktor 5-10 schneller sein als die „java run time“. Ist dies der Fall, ist alles in Ordnung. Man folgt den Anweisungen und kopiert die erzeugte libjbigi.so in den I2P-Installationsordner.

cp ~/i2p-VERSION/core/c/jbigi/lib/libjbigi.so ~/i2pbin/libjbigi.so 

Überprüfen der Änderung¶

Wird der Router nun gestartet (vorheriges Abschalten, kein Neustart), wird die Bibliothek jbigi geladen und verwendet. Geprüft werden kann dies auf der Seite http://localhost:7657/logs. Findet sich dort die Zeile "jbigi: Locally optimized native Biginterger library loaded from file" war die Aktion erfolgreich.

Auf der Seite http://localhost:7657/stats sollten nun die Werte crypto.elGamal.decrypt und crypto.elGamal.encrypt deutlich reduziert worden sein und der Router dadurch besser laufen. In meinem Fall etwa 25ms encrypt (vorher 450ms) und 140ms decrypt (vorher 2700ms).

I2P Log-Dateien in Ram auslagern¶

Man kann man die Log-Dateien des I2P-Routers als RAM-Disk auslagern. Entscheidet man sich dafür, muss man in der Datei ~/i2pbin/i2prouter in der Variable I2PTEMP den Pfad angeben, in dem die zuvor angelegten Ram-Disk eingebunden wurde. Zudem werden die Variablen PIDDIR und LOGDIR angepasst.

I2PTEMP="Pfad/zur/Ram-Disk"
PIDDIR="$I2PTEMP"
LOGDIR="$I2PTEMP/logs"

Journaling deaktivieren¶

Über den Sinn und Unsinn dieses Schrittes ist im Wiki-Artikel zum Thema TRIM ausführlich berichtet. Letztendlich muss jeder Nutzer für sich entscheiden, ob er die Gefahr eines Datenverlustes für den (geringen) Performance-Vorteil in Kauf nehmen möchte.

Entscheidet man sich dafür, kann man das Journaling bei ausgebundener Raspberry-Pi-Systempartition wie folgt deaktivieren (Partitionsbezeichnung sda1 entsprechend anpassen):

sudo tune2fs -O ^has_journal /dev/sda1 

Anschließend überprüft man, ob das Journaling tatsächlich deaktiviert wurde. In diesem Fall sollte unter "Filesystem features" nun kein has_journal mehr aufgeführt sein.

sudo tune2fs -l /dev/sda1 

Abschließend wird das Filesystem noch auch Fehler überprüft.

sudo e2fsck -f /dev/sda1 

Swap-Datei auslagern/deaktivieren/löschen¶

Das Schreiben von Daten aus dem Arbeitsspeicher in die Swap-Datei verursacht viele Schreibvorgänge und verschlechtert die Perfomance des Systems. Nach Möglichkeit sollte man das System so betreiben, dass ein Auslagerungsspeicher nicht nötig ist. In diesem Fall kann man die Swap-Datei deaktivieren bzw. löschen. Sollen auf dem System jedoch weitere speicherhungrige Programme laufen, kann man die Swap-Datei auch auf eine externe Festplatte auslagern, um die microSD-Karte zu schonen.

Wie man diese 3 Varianten unter Verwendung von dphys realisiert, ist auf der manpage 🇬🇧 beschrieben. Weitere Informationen und Möglichkeiten finden sich im Wiki-Artikel zu Swap.