TaskWarrior & TaskServer unter Linux, Windows & Android einrichten

TaskWarrior ist ein leistungsstarkes Open-Source-Tool zur Aufgabenverwaltung, das eine erweiterte Alternative zu Todo.txt und ähnlichen Anwendungen darstellt. In einer Welt, in der Menschen täglich mehrere Geräte nutzen, ist ein zentraler Zugriff auf Aufgabenlisten unerlässlich. Diese Anleitung zeigt dir, wie du den TaskServer (taskd) und den TaskWarrior-Client (task) einrichtest, sodass mehrere Endgeräte sicher synchronisiert werden können.

Hauptfunktionen

• Beliebig viele Aufgaben erstellen
• Prioritäten für Aufgaben festlegen
• Aufgaben mit Suchfunktionen filtern
• Tags zur Organisation verwenden
• Automatische Synchronisation über alle Geräte hinweg
• Integrierte Backup-Möglichkeiten
• Vollständige Kontrolle und Datenschutz
• Verschlüsselte Datenübertragung

Systemvoraussetzungen

• Ein CentOS 7 Server mit 64-Bit Architektur
• Ein Benutzerkonto mit sudo-Rechten
• Eine Domain, die auf deinen Server verweist (z. B. taskd.example.com)

Schritt 1: System aktualisieren

Melde dich mit einem Benutzerkonto an, das sudo-Rechte besitzt. Installiere dann das EPEL-Repository und aktualisiere das System mit folgenden Befehlen:

sudo yum install epel-release -y
sudo yum clean all && sudo yum update -y

Schritt 2: RPM-Build-Werkzeuge installieren und Build-Umgebung vorbereiten

Da das EPEL-Repository kein vorgefertigtes RPM-Paket für den TaskServer (taskd) enthält, musst du das Paket manuell aus dem Quellcode erstellen.

Installiere zuerst alle nötigen Werkzeuge zum Kompilieren und Signieren, einschließlich GCC, Make und RPM-Tools:

sudo yum install gcc gcc-c++ make rpmdevtools rpm-sign rpm-build -y

Erstelle anschließend ein Verzeichnis für die GnuPG-Dateien, die zum Signieren der RPMs benötigt werden:

mkdir .gnupg

Da die Erstellung eines Schlüsselpaares Entropie benötigt, installiere den rngd-Dienst, um Zufallsdaten aus /dev/urandom zu nutzen:

yum install rngd -y

Starte den rngd-Dienst mit folgender Anweisung:

sudo rngd -r /dev/urandom

Erzeuge nun ein GPG-Schlüsselpaar mit dem folgenden Befehl:

gpg --gen-key

Während der Erstellung bestätige folgende Eingaben:

• Option (1) RSA und RSA (Standard)
• Standardschlüssellänge 2048
• Keine Ablaufzeit
• y eingeben, um die Konfiguration zu bestätigen
• Name und E-Mail-Adresse eingeben
• Kommentar optional leer lassen
• O drücken, um die Erstellung abzuschließen
• Passwort setzen und bestätigen

Um den Inhalt des GPG-Verzeichnisses zu prüfen, nutze diesen Befehl:

ls -la .gnupg

Exportiere deinen öffentlichen Schlüssel in eine Datei und passe Name und Kennung entsprechend an:

gpg --export -a 'Joe Q. Public' > RPM-GPG-KEY-jqpublic

Importiere den Schlüssel anschließend in die RPM-Verwaltung:

sudo rpm --import RPM-GPG-KEY-jqpublic

Überprüfe, ob der Schlüssel korrekt hinzugefügt wurde:

rpm -q gpg-pubkey --qf '%{name}-%{version}-%{release} --> %{summary}\n'

Erstelle jetzt eine Datei .rpmmacros mit folgendem Editor-Befehl:

nano .rpmmacros

Füge den folgenden Inhalt ein und ersetze den Namen durch deine GPG-Angabe:

%_gpg_name  Joe Q. Public
%_query_all_fmt %%{name}-%%{version}-%%{release}.%%{arch}
%_signature gpg
%_topdir %(echo $HOME)/rpmbuild

Speichere mit STRG + X, dann S und abschließend ENTER.

Initialisiere die RPM-Ordnerstruktur mit folgendem Befehl:

rpmdev-setuptree

Überprüfe, ob alle erforderlichen Verzeichnisse erstellt wurden:

find rpmbuild

Lade den Quellcode von TaskServer (Version 1.1.0) in das SOURCES-Verzeichnis:

wget https://taskwarrior.org/download/taskd-1.1.0.tar.gz -P rpmbuild/SOURCES/

Beende abschließend den laufenden rngd-Dienst:

sudo kill -9 rngd

Schritt 3: TaskServer (taskd) RPM aus Quellcode erstellen

Um ein RPM-Paket für TaskServer zu generieren, wird eine sogenannte SPEC-Datei benötigt. Diese legt fest, wie der Quellcode kompiliert und verpackt werden soll. Die Datei muss im Verzeichnis rpmbuild/SPECS gespeichert werden.

Öffne und bearbeite die Datei mit folgendem Befehl:

nano rpmbuild/SPECS/taskd.spec

Füge den folgenden Inhalt in die Datei taskd.spec ein:

Name:           taskd
Version:        1.1.0
Release:        1%{?dist}
Summary:        Secure server providing multi-user, multi-client access to task data
Group:          Applications/Productivity
License:        MIT
URL:            http://tasktools.org/projects/taskd.html
Source0:        http://taskwarrior.org/download/%{name}-%{version}.tar.gz
Source1:        taskd.service
Source2:        taskd-config
Source3:        taskd.xml

BuildRequires:  cmake
BuildRequires:  libuuid-devel
BuildRequires:  gnutls-devel
BuildRequires:  shadow-utils

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
BuildRequires:  systemd
%endif

Requires:       gnutls-utils
Requires(post):    systemd
Requires(preun):   systemd
Requires(postun):  systemd

%description
The TaskServer provides secure, lightweight synchronization for task data across multiple clients and platforms. It enables users to maintain updated task lists from different devices and offers robust data exchange for systems without constant connectivity or identical features.

%prep
%setup -q %{name}-%{version}

%build
%cmake
make %{?_smp_mflags}

%install
make install DESTDIR=%{buildroot}

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
mkdir -p %{buildroot}%{_sysconfdir}/pki/taskd/
cp -a pki/generate* %{buildroot}%{_sysconfdir}/pki/taskd/.
mkdir -p %{buildroot}%{_localstatedir}/log/taskd/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
mkdir -p %{buildroot}%{_unitdir}/
cp -a %{SOURCE1} %{buildroot}%{_unitdir}/taskd.service
mkdir -p %{buildroot}%{_prefix}/lib/firewalld/services
cp -a %{SOURCE3} %{buildroot}%{_prefix}/lib/firewalld/services/taskd.xml
%endif

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/orgs/
cp -a %{SOURCE2} %{buildroot}%{_sharedstatedir}/taskd/config
rm -r %{buildroot}%{_datadir}/doc/taskd/

%pre
getent group taskd >/dev/null || groupadd -r taskd
getent passwd taskd >/dev/null || \
    useradd -r -g taskd -d %{_sharedstatedir}/taskd/ -s /usr/bin/sh \
    -c "Task Server system user" taskd
exit 0

%if 0%{?rhel} && 0%{?rhel} <= 6
%else

%post
%systemd_post taskd.service

%preun
%systemd_preun taskd.service

%postun
%systemd_postun_with_restart taskd.service

%endif

%files
%doc AUTHORS COPYING ChangeLog NEWS README
%{_bindir}/taskd
%{_bindir}/taskdctl
%{_mandir}/man1/taskd.1.*
%{_mandir}/man1/taskdctl.1.*
%{_mandir}/man5/taskdrc.5.*

%{_sysconfdir}/pki/taskd/generate*

%dir %attr(0750, taskd, taskd) %{_sysconfdir}/pki/taskd/
%dir %attr(0750, taskd, taskd) %{_localstatedir}/log/taskd/
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/
%config(noreplace) %attr(0644, taskd, taskd) %{_sharedstatedir}/taskd/config
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/orgs/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
%{_unitdir}/taskd.service
%{_prefix}/lib/firewalld/services/taskd.xml
%endif

%changelog
* Thu Aug 17 2017 Jarrett Graham <jarrett+rpmbuild@jarrettgraham.com> - 1.1.0
- Initial packaging.
</jarrett+rpmbuild@jarrettgraham.com>

Zusätzlich zur SPEC-Datei werden drei weitere Dateien benötigt. Beginne mit dem Erstellen der Datei taskd-config im Verzeichnis rpmbuild/SOURCES:

nano rpmbuild/SOURCES/taskd-config

Konfigurationsdatei für taskd erstellen

Füge nun die Konfigurationseinstellungen für TaskServer in die Datei taskd-config ein:

# taskd Konfigurationsdatei
confirmation=1
verbose=1
ip.log=on
extensions=/usr/libexec/taskd
queue.size=10
request.limit=1048576
server=0.0.0.0:53589
root=/var/lib/taskd
log=/var/log/taskd/taskd.log
pid.file=/var/run/taskd.pid
ca.cert=/etc/pki/taskd/ca.cert.pem
server.cert=/etc/pki/taskd/server.cert.pem
server.key=/etc/pki/taskd/server.key.pem
server.crl=/etc/pki/taskd/server.crl.pem

Systemd-Dienstdatei für TaskServer erstellen

Erstelle anschließend die taskd.service-Datei für systemd im rpmbuild/SOURCES-Verzeichnis:

nano rpmbuild/SOURCES/taskd.service

Trage folgenden Inhalt zur Definition des systemd-Dienstes ein:

[Unit]
Description=Secure server providing multi-user, multi-client access to task data
After=network.target
Documentation=https://tasktools.org/projects/taskd.html

[Service]
ExecStart=/usr/bin/taskd server --data /var/lib/taskd
Type=simple
User=taskd
Group=taskd

[Install]
WantedBy=multi-user.target

taskd.xml Firewall-Dienstdefinition erstellen

Die letzte unterstützende Datei ist taskd.xml. Sie definiert einen benutzerdefinierten Firewall-Dienst für den Zugriff auf TaskServer:

nano rpmbuild/SOURCES/taskd.xml

Füge den folgenden XML-Code in die Datei ein, um den Dienst zu beschreiben:

<!--?xml version="1.0" encoding="utf-8"?-->

  Task-warrior server
  This option allows you to connect to the task warrior server.

Notwendige Abhängigkeiten für den Build installieren

Installiere alle erforderlichen Pakete, die für den Bau des TaskServer benötigt werden:

sudo yum install cmake libuuid-devel gnutls-devel gnutls-utils -y

RPM-Paket für TaskServer kompilieren und signieren

Wechsle in das Verzeichnis rpmbuild/SPECS und starte den Build-Prozess. Gib bei Aufforderung das zuvor gesetzte GPG-Passwort ein, um das RPM zu signieren:

cd rpmbuild/SPECS/
rpm -ba --sign taskd.spec

Erstelltes TaskServer RPM installieren

Installiere das generierte RPM-Paket auf deinem CentOS-System, um die Einrichtung von TaskServer abzuschließen:

cd
sudo rpm -ivh rpmbuild/RPMS/x86_64/taskd-1.1.0-1.el7.centos.x86_64.rpm

Schritt 4: TaskServer (taskd) einrichten und konfigurieren

Damit sich TaskWarrior-Clients mit dem TaskServer (taskd) synchronisieren können, müssen entsprechende Server- und Client-Zertifikate erstellt werden. Die dafür benötigten Skripte befinden sich im Verzeichnis /etc/pki/taskd/.

Wechsle zum Benutzer root und navigiere zum Verzeichnis mit den Zertifikatstools:

sudo su -
cd /etc/pki/taskd/

Erstelle nun eine Datei mit dem Namen vars, in der die Werte für eine selbstsignierte Root-Zertifizierungsstelle (CA) definiert werden:

nano vars

Füge in die Datei vars folgende Parameter ein. Du kannst dabei Werte wie Organisation oder Domain nach Bedarf anpassen:

BITS=4096
EXPIRATION_DAYS=365
ORGANIZATION="centron.de."
CN=taskd.example.com
COUNTRY=US
STATE="New York"
LOCALITY="New York"

Erzeuge anschließend mit den folgenden Skripten die Root-CA, das Serverzertifikat, den privaten Schlüssel sowie optional eine Sperrliste:

./generate.ca
./generate.server
./generate.crl

Die Skripte erzeugen folgende Dateien im Verzeichnis /etc/pki/taskd/:

• ca.cert.pem
• ca.key.pem
• server.cert.pem
• server.key.pem
• server.crl.pem

Ändere Eigentümer und Zugriffsrechte, damit TaskServer auf diese Dateien zugreifen kann:

chown taskd.taskd ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem
chmod 400 ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem

Aktiviere und starte den TaskServer-Dienst mit systemd:

systemctl enable taskd
systemctl start taskd

Öffne den benötigten TCP-Port in der Firewall und lade die Konfiguration neu:

firewall-cmd --permanent --zone=public --add-port=53589/tcp
firewall-cmd --reload

Damit ist TaskServer (taskd) erfolgreich eingerichtet und betriebsbereit auf deinem CentOS 7 System.

Schritt 6: Erste TaskWarrior-Gruppe und Benutzer einrichten

Um Aufgaben mit TaskWarrior verwalten zu können, brauchst du ein Benutzerkonto. Bevor du Benutzer anlegst, musst du zunächst eine Organisationsgruppe erstellen. Verwende dazu folgenden Befehl und ersetze GROUP durch einen passenden Namen deiner Wahl:

Wichtig: Führe diesen Befehl unbedingt als Benutzer taskd aus – nicht als root. Andernfalls entstehen falsche Dateiberechtigungen im Verzeichnis /var/lib/taskd/orgs, was den Zugriff für Clients verhindert.

sudo -u taskd taskd add org GROUP --data /var/lib/taskd

Nach dem Erstellen der Gruppe kannst du nun den ersten Benutzer hinzufügen. Ersetze GROUP mit dem Namen deiner Gruppe und 'Joe Q. Public' durch den vollständigen Namen des Benutzers. Notiere dir unbedingt die generierten Zugangsdaten (Benutzername, Gruppe und Schlüssel) für spätere Konfigurationen:

sudo -u taskd taskd add user GROUP 'Joe. Q. Public' --data /var/lib/taskd

Schritt 7: TaskWarrior unter Windows 10 installieren

Um TaskWarrior unter Windows 10 (ab Build 1607) zu verwenden, musst du das Windows-Subsystem für Linux (WSL) installieren. Damit kannst du eine Linux-Umgebung nutzen, in der TaskWarrior über die Kommandozeile funktioniert.

Starte zunächst ein PowerShell-Fenster mit Administratorrechten. Drücke die Windows-Taste, suche nach PowerShell, klicke mit der rechten Maustaste darauf und wähle Als Administrator ausführen. Bestätige die Abfrage mit Ja und führe dann folgenden Befehl aus, um WSL zu aktivieren:

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Sobald die Installation abgeschlossen ist, drücke Y, um das System neu zu starten. Nach dem Reboot öffne die Eingabeaufforderung und gib folgenden Befehl ein:

bash

Dadurch wird Ubuntu installiert. Folge den Anweisungen und wähle einen Benutzernamen sowie ein Passwort.

Installiere TaskWarrior in der Linux-Shell mit folgendem Befehl:

sudo apt-get install task -y

Gib anschließend zweimal exit ein, um Bash und die Eingabeaufforderung zu schließen. Für schnellen Zugriff auf Bash: Öffne das Startmenü, suche nach Ubuntu, klicke mit der rechten Maustaste auf Bash on Ubuntu on Windows und wähle An Taskleiste anheften.

Klicke auf das Ubuntu-Symbol in der Taskleiste und führe diesen Befehl aus, um das Datenverzeichnis und die Konfigurationsdatei von TaskWarrior zu erzeugen:

task version
yes

Lege nun die Datei certificates.zip – die du zuvor während der Einrichtung von TaskServer erstellt hast – im Verzeichnis ~/.task/ ab. Installiere unzip, falls noch nicht vorhanden, und extrahiere die Datei wie folgt (passe den Pfad zu deinem Benutzer an):

sudo apt-get install unzip -y
cp /mnt/c/User/WINDOWSUSER/Desktop/certificates.zip .
cd .task
unzip ../certificates.zip
cd

Richte TaskWarrior ein, um mit dem TaskServer zu kommunizieren. Ersetze dabei die Platzhalter durch deine tatsächlichen Werte für Zertifikate, Gruppe, Benutzer und eindeutigen Schlüssel:

task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

Zum Abschluss initialisiere die Synchronisierung mit dem Server durch folgenden Befehl:

task sync init

TaskWarrior ist nun erfolgreich auf deinem Windows 10 System eingerichtet und mit dem TaskServer verbunden.

Schritt 8: TaskWarrior unter Android installieren

Um TaskWarrior auf einem Android-Gerät zu nutzen, lade die offizielle App TaskWarrior For Android aus dem Google Play Store herunter.

1. Öffne den Google Play Store und installiere TaskWarrior For Android.
2. Starte die App nach erfolgreicher Installation.
3. Gib beim ersten Start deinen gewünschten Kontonamen ein – dieser muss mit dem Benutzernamen übereinstimmen, den du zuvor im TaskServer erstellt hast.
4. Lass den Eintrag für den Datenordner auf dem Standardwert <<Create new>> stehen und tippe auf OK.
5. Erstelle mit einer Datei-Manager-App einen neuen Ordner auf deinem Gerät, z. B. unter /storage/emulate/0/Certs.
6. Speichere die zuvor erstellte certificates.zip Datei in diesem Ordner und entpacke sie vollständig.
7. Wechsle zurück zur TaskWarrior-App und öffne das Menü über das Symbol oben links.
8. Scrolle nach unten und wähle den Eintrag Einstellungen, um den internen Editor zu öffnen.

Trage dort folgende Einstellungen ein, um die Synchronisierung mit deinem TaskServer zu aktivieren. Ersetze NAME, GROUP, Joe Q. Public sowie den Benutzerschlüssel mit deinen tatsächlichen Werten:

taskd.ca=/storage/emulate/0/Certs/ca.cert.pem
taskd.certificate=/storage/emulate/0/Certs/NAME.cert.pem
taskd.credentials=GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
taskd.key=/storage/emulate/0/Certs/NAME.key.pem
taskd.server=taskd.example.com:53589

Nachdem du alle Daten eingegeben hast, speichere die Konfiguration über das Diskettensymbol.

Die TaskWarrior-App auf deinem Android-Gerät ist nun erfolgreich mit deinem TaskServer verbunden und synchronisiert.

Schritt 9: TaskWarrior unter Linux installieren

Um TaskWarrior unter Linux zu installieren, verwende das Paketverwaltungssystem deiner Distribution oder lade es direkt von der offiziellen TaskWarrior-Website herunter.

Nach der Installation öffne ein Terminal und führe den folgenden Befehl aus, um die Konfigurationsdatei und das Datenverzeichnis zu erstellen:

task version
yes

Verschiebe nun die Datei certificates.zip aus der TaskServer-Einrichtung in dein Home-Verzeichnis. Entpacke sie in das Verzeichnis ~/.task. Falls das Tool unzip nicht installiert ist, hole dies vorher über deinen Paketmanager nach. Führe dann folgende Befehle aus (Passe den Pfad zur ZIP-Datei bei Bedarf an):

cp /location/of/certificates.zip .
cd .task
unzip ../certificates.zip
cd

Konfiguriere nun TaskWarrior so, dass es sich mit dem TaskServer verbindet. Ersetze die Platzhalter NAME, GROUP, Joe Q. Public und den eindeutigen Benutzerschlüssel mit deinen tatsächlichen Werten:

task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

Starte anschließend die Synchronisierung mit folgendem Befehl:

task sync init

Tipp: Wer GNOME Shell verwendet, kann sich die Erweiterung „TaskWhisper“ ansehen, um TaskWarrior direkt ins Desktop-Erlebnis zu integrieren.

Dein TaskWarrior-Client ist nun erfolgreich mit dem TaskServer unter Linux verbunden und synchronisiert.

Fazit

Die Kombination aus TaskWarrior und TaskServer bietet dir eine sichere, plattformübergreifende und vollständig synchronisierte Lösung zur Aufgabenverwaltung. Ob unter CentOS, Windows, Linux oder Android – mit dieser Anleitung kannst du deine Aufgaben auf mehreren Geräten verwalten und synchron halten.

Durch die Verwendung von Zertifikaten und verschlüsselter Kommunikation ist die gesamte Umgebung auf Datenschutz und Kontrolle ausgelegt – ideal für Einzelpersonen und Teams. Nach dieser Einrichtung verfügst du über eine voll funktionsfähige, sichere und flexible Task-Management-Plattform, die sofort einsatzbereit ist.