Backup solution with Raspberry Pi – part 1

What I want to show you in this series is how to ...

  • (part 1) set up your Raspi to provide a mountable drive for your clients
  • (part 1) do an incremental and versioned back-up of your Linux clients to that drive via rsync
  • (part 2) mirror your backup to your friend's Raspi to have an (encrypted) copy in case of desaster
  • (part 2) include your phone or tablet into this scenario (well, kind of ...)
the hardware setup
(Icons made by srip from, licensed by CC 3.0 BY)

For this to work we only need the hardware and some basic Linux commands. This is what you'll need:

  • knowledge of basic Linux commands (sudo, mount, ...) and how to edit a file owned by root on the command line
  • ssh and root access (via sudo) on your Raspberry Pi
  • root access on the computers which are going to be backed-up

And these are the directories, device names and so on I will use in this article:

  • /dev/sda1: partition for the primary backup (see graphic above)
  • /media/Backup1: mount point for /dev/sda1
  • bean, luci: devices I want to backup (two Linux Mint laptops - my wife's and mine)
  • raspi: my Raspberry Pi
  • pi: the user I use to connect to my Raspiberry Pi (ssh pi@raspi)

Preparing your network

First, we must make sure, that the Raspberry Pi can address all laptops and desktops by their names or static IP addresses and vice versa.

static IP addresses and host names

To accomplish that I told my router (a Fritz-Box) to always give the same IP address to my Laptops and the Raspi. Then I edited the /etc/hosts file on all of them and added the names and corresponding IP addresses of the devices:

... other stuff here ...  bean  luci  raspi

... more other stuff here ...

I actually left out the corresponding line on the corresponding machine. Meaning: on bean I left out the " bean", on luci I left out the " luci" and so on.

Now I can address all of them by name or IP address. I prefer "by name". Like "ping luci" while being on raspi for example.

Another solution to accomplish this is to make your Router or your Raspberry Pi a DHCP server. But I wanted to keep it simple for now, concentrate on the backup task and not get caught up in other nasty fun stuff.

Setting up your Raspberry Pi

Ok, it's time to plug your designated backup drive into the Raspi right now. I formatted mine with an ext4 file system beforehand.

add the backup drive to /etc/fstab

Then create a mount point for it (here: mkdir /media/Backup1) and add your device to /etc/fstab. But first find out the UUID of your drive by issuing this command:

sudo blkid

My /etc/fstab entry for /dev/sda1 looks like this now:

UUID=a4ef22cd-b8ad-48f6-bd53-648805e9e58b /media/Backup1 ext4 defaults 0 1

I used the UUID instead of /dev/sda1 for device identification. This is more fail proof, because the partition /dev/sda1 of your backup drive may get a new name (e.g. /dev/sdb1) if you attach another drive to your Raspi.

NFS server

Now let's give the other devices access to the backup drive.

I did that by exporting the whole drive via NFS. NFS is perfect for laptops, because the mounts survive sleep mode flawlessly. You can also try Samba (SMB/CIFS); I won't, because I don't have any Windows installations here.

Some might say "Why do you want to mount that drive remotely? You can use rsync's remote copy abilities (root@raspi:/backup as target)!". Well, you could. But a) you would need to enter the Pi's root password every time you do a backup and b) I also have some media directories on that disk I want to provide to the client machines anyway and they will also be synced to the remote backup disk. (If you think not-mounting-the-drive-remotely is better for your purpose, just skip this part.)

Still on the Raspi install the NFS packages, ...

sudo apt install nfs-kernel-server

... edit /etc/exports and add something like this (all in one line) plus a helpful comment:

/media/Backup1 bean(fsid=0,rw,async,no_subtree_check,no_root_squash) luci(fsid=0,rw,async,no_subtree_check,no_root_squash)

# after changing anything here, do:
#   exportfs -ra && service nfs-kernel-server restart 

I added my two laptops (bean, luci) here by name. This means, no-one else should be able to mount the backup drive remotely.

You could only export a single directory of that drive, too. In my case I want to export the whole drive. It also holds GBs of media files which I want to be able to access from my laptops.

After editing /etc/exports run these commands to re-read the NFS configuration and restart the NFS server:

sudo exportfs -ra && sudo service nfs-kernel-server restart

NFS won't start at boot time

There's one problem with NFS left: if you'd reboot your Raspberry Pi now, you would see that the NFS server hadn't started at boot time. This is because NFS is started before rpcbind or so. But the NFS server needs rpcbind to run. We can tell the Raspi that there is a dependency between these two by adding this to a new file called /etc/systemd/system/nfs-kernel-server.service.d/10-dep.conf:


On the next boot the NFS server will start automagically now.

bonus: securing sudo on the Raspberry Pi

You might have noticed, that sudo on the Raspi doesn't ask for a password. This is odd. And insecure. It actually is insane.

But if you don't experience this or don't know what you're doing, please skip this part of this How-To. I also don't know on which versions of Raspian-OS this happens. Mine is a Raspberry Pi 3 B+ of November 2018.

To make sudo ask for a password I had to add the user pi to the sudo group. I even had to create the sudo group first:

sudo su -
groupadd -g 27 sudo
usermod -a -G sudo pi
# leave this shell open! If something goes wrong, you might lock yourself out!

Then uncomment the line starting with "pi" in /etc/sudoers.d/010_pi-nopasswd.

Now connect to your Raspi from another terminal session, to check if you can still do things like "sudo ls". If not, don't close the other ssh session and repair that!

Mount your backup drive

On the Linux devices you want to backup, install the NFS client first and create a mount point for the remote drive:

sudo apt install nfs-common
sudo mkdir /media/Backup1 # this is the local mount point for the drive

Add the drive to /etc/fstab now. My entries look like this:

raspi:/media/Backup1 /media/Backup1 nfs defaults 0 0

To check if mounting works, do this:

sudo mount /media/Backup1
sudo touch /media/Backup1/x # checks write access

In your nautilus or nemo or whatever file browser you use, you should see the drive now and be able to access it - depending on the rights you set on the files and directories on it.

Back it up now!

There's some more to do and think about: Write a backup script, choose where to put it, what to include in / exclude from the backup and finally how to start the backup...

If you don't want to write your own scripts, you can also try other backup solutions like Back In Time, rsnapshot or rsbackup. But I wanted to write my own:

a backup script to start with

The following is my backup script which I run on each of my clients bean & luci:


# set terminal window title
wmctrl -r :ACTIVE: -N "Backing Up $HOSTNAME"


if [ ! -d "$TARGET" ]; then
  dialog --msgbox "$TARGET does not exist - aborting ..."
  exit 1

# pre backup

# gather some infos
mkdir -p /root/backup/
dpkg -l > /root/backup/dpkg.get-selections

# dump databases
# mysqldump -u root -p******** --all-databases > /root/backup/mysql.dump

# END OF pre backup

# temp files
PROG=$( basename "$0" )

# excluded paths
echo "# excludes
/home/*/.config/google-chrome/Default/Service Worker/CacheStorage

# do backup to external drive
VERSIONING_TARGETDIR=$( date "+%Y-%m-%d_%H:%M:%S" )
rsync -a \
  --progress \
  --backup --backup-dir="$TARGET/$VERSIONING_TARGETDIR/" \
  --delete --delete-excluded \
  --exclude-from="$EXCLUDE" \
  / "$TARGET/latest/" \
  2> "$ERRORS"

CLOSEMSG="* you can close this window now *"
if [ -f "$ERRORS" -a $( cat "$ERRORS" | wc -l ) -ne 0 ]; then
  MSG="$HOSTNAME backup completed with errors:"
  ERRORS=$( cat "$ERRORS" )
  #spd-say "$HOSTNAME backup complete with errors"
  dialog --title "Backup completed" --msgbox "$MSG\n\n$ERRORS\n\n$CLOSEMSG" 1000 1000
  MSG="$HOSTNAME backup completed without errors"
  #spd-say "$HOSTNAME backup complete without errors"
  dialog --title "Backup completed" --msgbox "$MSG\n\n$CLOSEMSG" 9 50

I changed it's access rights like this, so everyone can start it but only root can change it:

sudo chown root:root raspi-backup
sudo chmod 755 raspi-backup

It also uses the dialog command, so install that:

sudo apt install dialog

Some comments about the script:

  • $TARGET: this is the indiviual backup target
  • $HOSTNAME: Be aware: this is used to define the directory name into which the files are backed up. A malicious user could use this to overwrite another one's backup. Keep your host's names distinguishable!
  • # pre backup: here I do some things like making a list of the installed packages and dump my mysql database to a file
  • $EXCLUDE: this is the list of files and directories I don't want to backup. As I do a backup starting at the root directory / I exclude almost everything but /etc, /home and /root
  • $VERSIONING_TARGETDIR: this is the directory name for the --backup-dir option. It is a timestamp, for example "2019-01-02_15:23:04"
  • rsync options:
    • --delete and --delete-excluded: will delete files on the backup drive that are not existing on the client anymore
    • --backup: this tells rsync to not delete or overwrite anything - this is what makes the backup a versioned backuprsync's parameters:
    • --backup-dir: rsync before overwriting or deleting anything, rsync moves the old versions of these files to this directory
    • $TARGET/latest/: this is the directory where the backup will be put

where to put the script

I put the script on my backup drive under the name raspi-backup. It is suitable for both the laptops that I back-up with it.

If you need individual scripts for individual machines, you might just want to put them in the root directory of the laptops / desktop computers.

start the backup script

On your client machine the above script can be started like this now:

sudo /media/Backup1/raspi-backup

If you want to allow your user(s) to start it without entering a password (because of sudo), you can put something like this into your sudoers file by using the "sudo visudo" command:

krst ALL=(ALL) NOPASSWD: /media/Backup1/raspi-backup

krst is the username and raspi-backup is the script he is allowed to run without issuing a password. Nice and safe, eh?!

But wouldn't it even be nicer to just click on an icon on your desktop to start the backup? Let's do that!

On my Linux Mint 19 laptops I wrote this litle file named Backup.desktop and shoved it to my ~/Desktop folder. I think it will work on any Ubuntu based distribution:

[Desktop Entry]
Exec=sudo /media/Backup1/raspi-backup

My wife and me, we have different user names on our individual laptops. But their UIDs are the same (UID 1000). That's why we can peek into the other one's backed up files and they appear as if they are written with our own user. If you don't want this, you can ...

  1. change the UID of the users
  2. use /etc/export to only export the indiviual backup target (backup-$HOSTNAME) directory for the individual client

Final thoughts

This backup solution is basic, but it works without any backup file cataloges, strange or even proprietary backup file formats or databases. You can just restore your files from the backup media without any extra software.

If you have huge files like Virtual Box VMs in .vdi files, this can become quite nasty because it takes long time to back these files up. Especially over Wifi. Maybe I can find a solution for this.

possible improvements

  • Why not try letting the Raspberry Pi start the backup? It can ping the indiviual machines now and then and when they are up => grab the data. When done => sync to mirror backup media.

If you have any thoughts on this - feel free to leave a comment!

The second part is not released yet - I even haven't done the hardware setup right now... But it will come in the first quarter of 2019 - promised!

Have fun!

sniff own https traffic

In a Java programming project I needed to see what SOAP request my application sends out to a server. Everything soapy was done inside a 3rd-party-library and I couldn't make it log the request to the console.

So what I did was using a tool called mitmproxy. This provides a man-in-the-middle proxy server that accepts HTTP calls and can forward them via HTTPS.

First you need to create a configuration file. Mine is named and looks like this (it actually is a python program):

def request(context, flow):
  flow.request.scheme = 'https'
  flow.request.port = 443

Then fire up the server by running:

mitmproxy -s

Now tell your Java program to use a http proxy server by starting it with these JVM parameters:

-Dhttp.proxyHost=localhost -Dhttp.proxyPort=8080

To learn how to use mitmproxy's UI, check out their website.

Ubuntu: User verstecken

Möchte man am Anmeldebildschirm und im Unity-Menü oben rechts einen User nicht anzeigen, hilft die Information, dass dort nur User sichtbar sind, deren UID >= 1000 ist.

Mit dem Befehl

sudo usermod -u 888 <username>

kann man die UID eines Users ändern. Danach ist er vom Anmeldebildschirm und aus dem Unity-Menü verschwunden.

Android, S4 mini: externe SD-Karte kaputt

Jetzt ist es schon zum 2. Mal passiert: die SD-Karte in meinem Samsung S4 mini hat sich verabschiedet. Ich soll sie formatieren, sagt Android. Aber wenn ich das tue, macht er es nicht. Auch im Recovery geht es nicht.

Hier ein paar Tipps:

  • unter Windows hilft angeblich ein chkdsk /X /F <driveletter>:
  • Installier testdisk, lass es als root laufen. Karte steckt im (USB-)SD-Karten-Adapter. Damit kannst du wenigstens die Dateien retten.
  • mach danach im Zielordner ein find -name "_*" -exec file {} \;. Damit findest du Dateien, deren Namen nicht mehr korrekt gerettet werden konnten.
  • zum wieder lesbar machen der SD-Karte: starte testdisk nochmal und versuch diese Optionen: (danach sind aber trotzdem sicherlich einige Dateien nicht lesbar oder haben 0 Byte -> find -size 0 -exec rm {} \; ):

>Create a new log file
[Choose Disk]
>Intel/PC partition
[Choose Partition]
>Repair FAT
[Accept Defaults and Write]
>(Q)uit until exited

Meine beste Lösung bei diesem Problem ist:

  1. Daten sichern mit testdisk
  2. SD-Karte wieder lesbar machen
  3. Karte formatieren im Recovery oder mit gparted (fat32)
  4. Backup aufspielen und danach die Dateien aus dem ersten Schritt aufspielen

Aktuelle mysql-Version für Uberspace kompilieren

Auf kann es passieren, dass die installierte MySQL-Version veraltet ist und man eine aktuellere Version verwenden möchte. Hier die Schritte um das zu realisieren.

In Kürze bedeutet es: CentOS installierenMySQL kompilierenkompilierte Version von MySQL zu Uberspace übertragenMySQL einrichtenStartscripte erstellenz.B. in WordPress verwendenaufräumenBackup einrichten

Ich benutze folgende beispielhafte Konventionen in dieser Anleitung:

  • grobi: der Username auf
  • enif: der Servername auf dem der Uberspace-Account liegt. Alle Server haben Namen von Sternen oder Sternbildern. Z.B. oder
  • ich verwende hier CentOS 6.6
  • ich installiere hier im Beispiel die MySQL-Version 5.6.24
  • ich installiere die Version nach ~/.mymysql
  • die MySQL-Version soll auf Port 33306 laufen

CentOS installieren

Zuerst finden wir raus, welche CentOS auf uberspace läuft. Also per SSH verbinden und dieses Kommando absetzen:

> cat /etc/redhat-release
CentOS release 6.6 (Final)

Also laden wir erstmal die Version herunter: Minimal ISO 64 Bit von Danach diese Version installieren, z.B. in eine VirtualBox VM.

  • Deutsches System
  • Rechnername: enif (siehe oben)
  • Netzwerk konfigurieren: eth0 bearbeiten → Automatisch verbinden
  • Zeitzone: Berlin

Nach der Installation loggen wir uns als root ein und richten einen Account für grobi ein:

> adduser grobi
> passwd grobi

MySQL kompilieren

Jetzt als root ein paar Pakete installieren:

> yum install wget cmake gcc-c++ ncurses-devel

Wir loggen uns als grobi ein, damit wir beim kompilieren auch ja nicht in den Genuss von root-Rechten kommen, denn die haben wir ja auf Uberspace auch nicht. Nicht dass da was passiert, was uns nachher - als normaler User - das Genick bricht.

> sudo su - grobi

Nun laden wir die gewünschte MySQL als Sourcen herunter:

  • per Browser auf einem anderen Rechner auf gehen
  • "Source Code" und "Generic Linux" auswählen
  • bei "Compressed TAR Archive" auf Download klicken
  • auf der nächsten Seite den Link "No thanks, just start my download." kopieren
  • im CentOS mit wget die Sourcen runterladen, entpacken und ins Verzeichnis wechseln. Z. B.:

> wget
> tar xzf MySQL-5.6.24.tar.gz
> cd mysql-5.6.24

Zum kompilieren müssen wir ein paar Optionen mitgeben (mehr hier: und dann geht's los:

> cmake -DCMAKE_INSTALL_PREFIX=/home/grobi/.mymysql/ -DSYSCONFDIR=/home/grobi/.mymysql/
> make
> make install

zu Uberspace übertragen

MySQL 5.6 ist nun im Verzeichnis /home/grobi/.mymysql installiert. Wir übertragen das ganze Verzeichnis in unser $HOME auf Uberspace. Z.B. mit scp:

> cd
> tar czf mymy.tgz .mymysql/
> scp mymy.tgz # nicht den Doppelpunkt am Ende vergessen

Es sind ca. 1 GB Daten - gepackt ein Viertel davon. Keine Ahnung, was davon alles wirklich benötigt wird... Vielleicht fummel ich das später mal raus ...

Fahr dein CentOS jetzt runter, es frisst nur Strom.

MySQL einrichten

Unser selbst installiertes CentOS hat jetzt ausgedient. Wir brauchen es nicht mehr. Eigentlich. Wenn du eventuell noch ein paar andere Optionen beim Kompilieren ausprobieren willst, solltest du es noch nicht wegwerfen.

Wir loggen uns erstmal per ssh auf unserem Uberspace ein, entpacken die übertragene Datei und wechseln ins Installationsverzeichnis

> ssh
> tar xzf mymy.tgz
> cd .mymysql/

Next step: Wir erstellen hier die Datei my.cnf mit diesem Inhalt:



Wir erstellen jetzt die Systemtabellen und können dann unseren MySQL-Server starten:

> scripts/mysql_install_db --basedir=/home/grobi/.mymysql/
> bin/mysqld

Nun noch root-Passwort vergeben und ein paar Einstellungen machen (auf einer weiteren Konsole). Dazu muss die Datei bin/mysql_secure_installation angepasst werden, so dass korrekte Werte für port und protocol verwendet werden (dies kann bei MySQL 5.7 angeblich per Kommandozeile geschehen). MySQL 5.6: In der Funktion "sub make_config" fügen wir diese Werte hinzu (nur die 2. Zeile ist neu):

"socket=''", "port=33306", "protocol=TCP", # diese Zeile einfügen

Und ausführen:

> bin/mysql_secure_installation

  • current password: Enter
  • set root password: Y
  • remove anonymous users: Y
  • disallow root login remotely: Y
  • remove test database and access to it: Y
  • reload privilege tables now: Y

Ok! Wir haben fertig und die Datenbank läuft! Cool? Sehr cool!

Jetzt kann man mit

> bin/mysql --port=33306 -u root -p

das Client-Programm verwenden. Dafür sollte man sich einen Alias einrichten. Zum Beispiel so:

> alias mymy='/home/grobi/.mymysql/bin/mysql --port=33306'

Dies funktioniert bei mir ohne User / Password, weil in der schon vorhandenen ~/.my.cnf Passwort und User der alten MySQL-Version stehen. Ich habe für die 5.6er die gleichen Werte für User und Passwort ringerichtet.

Startscripte erstellen

Auch Uberspace-Server werden wohl ab und an mal neugestartet. Selten, aber wenn, dann soll unser MySQL beim hochfahren mitgestartet werden.

> uptime
05:58:35 up 301 days, 10:50, 0 users, load average: 0.29, 0.51, 0.50

Dazu müssen wir einen Service einrichten. Die ganze Anleitung dazu gibt es hier: Wir beginnen mit der Vorbereitung:

> test -d ~/service || uberspace-setup-svscan

Schreib jetzt ein Script ~/bin/mymysqld das den MySQL-Daemon startet und mach es ausführbar. Inhalt:


exec ~/.mymysql/bin/mysqld

Die Startscripte erstellst du mit

> uberspace-setup-service mymysqld ~/bin/mymyslqd

Hier kannst du nachlesen, wie du ausprobierst, ob das Starten und Stoppen funktioniert (-u / -d / usw). Loggingausgaben kannst du dir mit

> tail -f ~/service/mymysqld/log/main/*

anzeigen lassen.

Beispiel: in WordPress verwenden

In WordPress musst du die DB_HOST Variable so setzen:

define('DB_HOST', ''); /* nicht localhost verwenden */


  • dein selbst installiertes CentOS kann jetzt gelöscht werden
  • Datei mymy.tgz im Home deines Uberspace kann gelöscht werden

Backup einrichten

So! Nachdem nun alles sauber läuft, sollte man sich noch um den Backup kümmern. Denn auch wenn dein Server gesichert wird, ist es keine gute Idee, auf eine Dateisicherung des MySQL-Arbeitsverzeichnisses zu vertrauen. Hier im Beispiel machen wir einen MySQL-Dump in die Datei ~/.mymymsql/backup.dump.

~/.mymysql/bin/mysqldump --host= --port=33306 --all-databases > ~/.mymysql/backup.dump

Diesen Befehl in die crontab und gut ist. Denn die Datei backup.dump wird ja beim nächsten Backup mitgesichert.

Man beachte: während eines Dumps wird die Datenbank kurz gesperrt. Bei großen Datenbanken kann das natürlich zu Problemen führen (siehe auch hier).

Ubuntu 14.04: Tastatur auf “englisch” eingestellt nach Neustart

Wenn deine Tastatur ständig auf englisch anstatt auf deutsch eingestellt ist, wenn du den Rechner neu startest, kannst du das so in den Griff bekommen:

  • installier den dconf-editor
  • öffne ihn
  • geh zu desktop -> ibus -> general
  • setz das Häkchen bei "use-system-keyboard-layout"

Jetzt sollte deine Tastatur nach einem Neustart deutsch eingestellt sein.

Papierkorb statt Nirvana

Wer schon böse Erfahrung mit dem rm Befehl gemacht hat - und wer hat das nicht - kann stattdessen gvfs-trash benutzen (unter Ubuntu). Die Dateien landen dann halt im Papierkorb. Dazu noch einen kleinen Alias, dann passt das schon:

alias mr='gvfs-trash'
mr ganz-wichtige-datei # liegt jetzt im Papierkorb

Außerdem spart man sich das lästige -rf beim Löschen von Verzeichnissen.

Traffic per SSH über einen anderen Server umleiten

Willst du z. B. deine echte IP verschleiern (anonymisieren), kannst du deinen Traffic per ssh über einen anderen Server tunneln und am anderen Ende sieht es dann so aus, als wäre deine IP die des Servers.

Dazu installierst du zuerst das Tool sshuttle:

sudo apt-get install sshuttle

Danach startest du es folgendermaßen:

sshuttle --dns -v -r 0/0

Auf dem Server oder im Browser brauchst du nichts mehr einstellen, ab jetzt läuft jedweder Traffic über den Tunnel! Ich habe es mit meinem uberspace-Server ausprobiert: es klappt einwandfrei!

Testen kannst du das ganze z. B. mit

Linux: Firefox erzeugt OOM

Seitdem ich bei Firefox "Hardwarebeschleunigung verwenden" unter Einstellungen > Erweitert > Allgemein aktiviert habe stürzt Firefox regelmäßig ab. Das läuft so ab:

  • Firefox aufmachen
  • surfen
  • Maus fängt an zu haken
  • alles friert ein
  • mit Alt-Strg-F6 auf Konsole wechseln (dauert teilweise mehr als eine Minute)
  • einloggen (ist gut, wenn man das vorher gemacht hat)
  • eventuell bekommt man noch eine Meldung zu sehen a la "Out of memory kill process (firefox) score 741 or sacrifice child"
  • killall Browser; killall firefox hilft


  • Firefox im safe mode starten: firefox -safe-mode
  • in den Einstellungen die Hardwarebeschleunigung abschalten
  • Firefox neu starten

und wenn das doch nicht hilft:

  • Firefox im safe mode starten: firefox -safe-mode
  • alle Add-Ons deaktivieren
  • Firefox neu starten
  • Add-Ons je nach bedarf wieder aktivieren und drauf achten, nach welcher Aktivierung das Problem wieder auftritt

Elance Tracker in Ubuntu 14.04 installieren

Zuerst muss Adobe Air installiert werden:

sudo dpkg --add-architecture i386
sudo apt-get update
sudo apt-get install libxt6:i386 libnspr4-0d:i386 libgtk2.0-0:i386 libstdc++6:i386 libnss3-1d:i386 lib32nss-mdns libxml2:i386 libxslt1.1:i386 libcanberra-gtk-module:i386 gtk2-engines-murrine:i386 libgnome-keyring0:i386
sudo ln -s /usr/lib/x86_64-linux-gnu/ /usr/lib/
sudo ln -s /usr/lib/x86_64-linux-gnu/ /usr/lib/
chmod a+x AdobeAIRInstaller.bin
sudo ./AdobeAIRInstaller.bin

Jetzt kann der Tracker installiert werden:

Erstmal den Tracker als DEB hier runterladen. Dann:

sudo dpkg -i --force-architecture TrackerSetup.deb

Jetzt kann man den Tracker aus dem Dash heraus starten.