TaskWarrior und TaskServer auf CentOS 7 installieren und einrichten

TaskWarrior ist ein kostenloses Open-Source-Tool zur Aufgabenverwaltung, das über die Funktionen der ursprünglichen Todo.txt-Anwendung und ihrer Nachbildungen hinausgeht. Da viele Nutzer täglich mit mehreren Geräten und Plattformen arbeiten, ist es entscheidend, eine zentrale Datenquelle zu haben, die von überall aus aktualisiert und abgerufen werden kann. In dieser Anleitung wird beschrieben, wie der TaskServer (taskd) sowie der Client TaskWarrior (task) eingerichtet werden, um eine sichere und plattformübergreifende Synchronisation von Aufgaben zu ermöglichen.

Zentrale Funktionen

• Unbegrenzte Anzahl an Aufgaben
• Möglichkeit zur Priorisierung von Aufgaben
• Suchfunktionen mit Filteroptionen
• Tagging zur besseren Kategorisierung
• Automatische Synchronisation
• Automatische Backups
• Volle Kontrolle und Eigentum der Daten beim Nutzer
• Verschlüsselte Datenübertragung

Systemvoraussetzungen

• Ein CentOS 7 x64 Server
• Ein Benutzerkonto mit sudo-Rechten
• Eine Domain (z. B. taskd.example.com), die auf den Server zeigt

Schritt 1: System aktualisieren

Logge dich mit einem Benutzer ein, der über sudo-Rechte verfügt. Installiere anschließend das EPEL-Repository und führe eine komplette Systemaktualisierung durch:

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

Schritt 2: RPM-Build-Tools und Entwicklungswerkzeuge einrichten

Da das EPEL-Repository kein vorkompiliertes RPM-Paket für den TaskServer (taskd) bereitstellt, muss dieser aus dem Quellcode kompiliert und als RPM-Paket erstellt werden.

Entwicklungstools und Abhängigkeiten installieren

Installiere GCC, Make sowie RPM-Entwicklungs- und Signierwerkzeuge mit folgendem Befehl:

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

GnuPG-Konfigurationsverzeichnis erstellen

Erstelle zunächst ein Verzeichnis, in dem die GPG-Konfigurationsdateien für die Signierung deines benutzerdefinierten RPM-Pakets gespeichert werden:

mkdir .gnupg

Entropie-Dienst installieren

Für die sichere Erstellung eines kryptografischen Schlüssels benötigt dein System ausreichend Entropie. Der Daemon rngd liefert diese, indem er Zufallswerte aus /dev/urandom bezieht. Installiere ihn mit folgendem Befehl:

yum install rngd -y

Starte den rngd-Dienst und weise ihn an, /dev/urandom als Quelle für Zufallszahlen zu nutzen:

sudo rngd -r /dev/urandom

GPG-Schlüsselpaar erzeugen

Nun erzeugst du ein neues GPG-Schlüsselpaar zur Signierung von RPM-Paketen. Verwende dafür den folgenden Befehl:

gpg --gen-key

Während des Vorgangs wirst du zu folgenden Einstellungen aufgefordert:

• Wähle Option 1 für „RSA und RSA (Standard)“ und bestätige mit Enter.
• Bestätige die voreingestellte Schlüssellänge 2048 mit Enter.
• Drücke Enter, um die Standardgültigkeitsdauer zu übernehmen.
• Gib y ein und bestätige mit Enter, um fortzufahren.
• Gib deinen gewünschten Namen im Feld Real name ein.
• Trage deine bevorzugte E-Mail-Adresse ein.
• Das Feld Kommentar kannst du leer lassen.
• Wenn alle Angaben korrekt sind, gib ein großes O ein und bestätige mit Enter.

GPG fordert dich dann auf, ein Passwort für das neue Schlüsselpaar einzugeben und zu bestätigen. Nach Abschluss werden die Schlüsseldateien im Verzeichnis .gnupg in deinem Home-Verzeichnis gespeichert.

Schritt 3: GPG-Schlüssel exportieren und für RPM konfigurieren

Inhalte des GPG-Verzeichnisses anzeigen

Mit dem folgenden Befehl kannst du überprüfen, welche Dateien sich im .gnupg-Verzeichnis befinden. Du solltest einen Ordner namens private-keys-v1.d sowie Dateien wie pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent und trustdb.gpg sehen:

ls -la .gnupg

GPG-Schlüsselpaar exportieren

Exportiere jetzt dein zuvor erzeugtes GPG-Schlüsselpaar. Die Option --export sagt GnuPG, dass ein Schlüssel exportiert werden soll, und -a gibt an, dass das Ergebnis im ASCII-Format erfolgen soll. Ersetze Joe Q. Public durch den tatsächlichen Namen, den du bei der Schlüsselgenerierung angegeben hast, und jqpublic durch deinen individuellen Bezeichner:

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

GPG-Schlüssel ins RPM-System importieren

Importiere den exportierten Schlüssel in das RPM-Schlüsselsystem. Ersetze dabei jqpublic durch deinen gewählten Namen:

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

Importierten Schlüssel überprüfen

Stelle sicher, dass dein Schlüssel korrekt in die RPM-Schlüsselverwaltung übernommen wurde. Der folgende Befehl gibt die Informationen in einem lesbaren Format aus:

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

Die Datei .rpmmacros erstellen und bearbeiten

Um das Verhalten von RPM anzupassen, erstelle mit dem Texteditor nano eine neue Datei mit dem Namen .rpmmacros:

nano .rpmmacros

Füge den folgenden Inhalt ein, um deine GPG-Identität sowie die Pfade für den RPM-Build-Prozess festzulegen. Ersetze Joe Q. Public durch den Namen, den du bei der Erstellung deines GPG-Schlüssels verwendet hast:

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

Zum Speichern und Beenden drücke CTRL + X, dann S und anschließend Enter.

RPM-Build-Umgebung initialisieren

Richte die erforderliche Verzeichnisstruktur für den RPM-Build ein. Mit dem folgenden Befehl werden zusätzlich hilfreiche Makros zur Datei .rpmmacros hinzugefügt:

rpmdev-setuptree

RPM-Verzeichnisinhalt prüfen

Überprüfe, ob die Einrichtung korrekt erfolgt ist, indem du den Inhalt des Verzeichnisses rpmbuild auflistest. Du solltest darin die Unterordner SOURCES, RPMS, BUILD, SRPMS und SPECS finden:

find rpmbuild

TaskServer-Quellcode herunterladen

Lade das Quellarchiv für den TaskServer herunter und speichere es im Verzeichnis rpmbuild/SOURCES:

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

rngd-Prozess beenden

Da die Generierung von Entropie nun abgeschlossen ist, kannst du den Dienst rngd mit folgendem Befehl beenden:

sudo kill -9 rngd

Schritt 4: TaskServer (taskd) als RPM-Paket kompilieren

Um ein RPM-Paket für TaskServer zu erstellen, muss eine sogenannte SPEC-Datei angelegt werden. Diese legt fest, wie das Paket gebaut und installiert wird.

Die SPEC-Datei erstellen

Erstelle eine neue Datei namens taskd.spec im Verzeichnis rpmbuild/SPECS mit folgendem Befehl:

nano rpmbuild/SPECS/taskd.spec

Füge den folgenden vollständigen Inhalt in diese Datei 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
# Auf RHEL ist systemd nicht zum Bauen nötig – auf CentOS hingegen schon.
# ...nur um Makros zu definieren
%else
BuildRequires:  systemd
%endif

# Für die Erstellung von Zertifikaten
Requires:       gnutls-utils

# Abhängigkeiten für systemd
Requires(post):    systemd
Requires(preun):   systemd
Requires(postun):  systemd

%description
Der TaskServer ist ein schlanker und sicherer Server, der Multi-User- und Multi-Client-Zugriff auf Aufgaben ermöglicht. Dadurch wird echtes Synchronisieren zwischen Desktop- und mobilen Clients möglich.

Benutzer möchten auf ihre Aufgabenlisten von mehreren Geräten mit unterschiedlicher Software zugreifen und diese nahtlos synchronisieren. Dafür müssen Transaktionen ausgetauscht werden können – auch wenn die Geräte nicht ständig verbunden oder gleich leistungsfähig sind.

Der TaskServer ermöglicht genau das und bietet darüber hinaus eine solide Basis für weitergehende Funktionen.

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

%build
%cmake
make %{?_smp_mflags}

%install
make install DESTDIR=%{buildroot}

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/

# Benutzer speichern hier ihre Schlüssel; zusätzlich werden hilfreiche Skripte kopiert.
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
# EL6 benötigt ein SysVinit-Skript und kennt kein firewalld
%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

# systemd-Skripte
%if 0%{?rhel} && 0%{?rhel} <= 6
# Kein systemd unter EL6
%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
# Kein SysVinit unter EL6
%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
- Erstveröffentlichung
</jarrett+rpmbuild@jarrettgraham.com>

Schritt 5: Zusätzliche Dateien für das RPM-Paket erstellen

Für den erfolgreichen Build des TaskServer-RPMs werden drei zusätzliche Dateien benötigt. Diese müssen im Verzeichnis rpmbuild/SOURCES gespeichert werden: eine Konfigurationsdatei, eine systemd-Dienstdatei sowie eine XML-Datei für die Firewall-Konfiguration.

Datei taskd-config erstellen

Nutze den Texteditor nano, um die Konfigurationsdatei für TaskServer zu erstellen:

nano rpmbuild/SOURCES/taskd-config

Füge den folgenden Inhalt in die Datei ein:

# Konfigurationsdatei für taskd
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

Datei taskd.service erstellen

Erzeuge nun die systemd-Dienstdefinition ebenfalls mit nano:

nano rpmbuild/SOURCES/taskd.service

Trage folgenden Inhalt für die Dienstkonfiguration 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

Datei taskd.xml erstellen

Erstelle abschließend mit nano die XML-Datei für die Integration in firewalld:

nano rpmbuild/SOURCES/taskd.xml

Füge den folgenden XML-Inhalt ein, der den TCP-Port für TaskServer beschreibt:

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

Schritt 6: TaskServer als RPM kompilieren und installieren

Bevor das RPM-Paket für TaskServer (taskd) erstellt werden kann, müssen die nötigen Abhängigkeiten installiert werden, die für den Build-Vorgang erforderlich sind. Dazu gehören CMake, UUID-Bibliotheken und GnuTLS.

Notwendige Build-Abhängigkeiten installieren

Führe folgenden Befehl aus, um die erforderlichen Entwicklungspakete und Bibliotheken zu installieren:

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

TaskServer als RPM-Paket erstellen

Wenn alle Voraussetzungen erfüllt sind, kannst du mit dem Erstellen des RPM-Pakets aus dem Quellcode beginnen. Wechsle dazu in das Verzeichnis, das die SPEC-Datei enthält, und starte den Build. Auf einem System mit nur einem CPU-Kern dauert dieser Vorgang in der Regel weniger als eine Minute. Gib dein GPG-Passwort ein, wenn du zur Signierung des Pakets aufgefordert wirst:

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

Erstelltes RPM installieren

Nach erfolgreicher Erstellung kehre in dein Home-Verzeichnis zurück und installiere das neu generierte RPM-Paket mit folgendem Befehl:

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

Schritt 7: TaskServer für die Client-Kommunikation konfigurieren

Damit TaskServer (taskd) mit TaskWarrior (task) Clients kommunizieren und synchronisieren kann, müssen passende Server- und Client-Zertifikate erstellt werden. Diese erzeugst du mit Hilfe von Skripten, die sich im Verzeichnis /etc/pki/taskd/ befinden.

Zum root-Benutzer wechseln und ins Zertifikatsverzeichnis navigieren

Wechsle zum Benutzer root und gehe ins entsprechende Verzeichnis:

sudo su -
cd /etc/pki/taskd/

Datei „vars“ für Root-CA-Konfiguration anlegen

Erstelle mit nano eine Datei namens vars, in der die Details der Zertifizierungsstelle definiert werden:

nano vars

Füge den folgenden Inhalt ein und passe Organisation, Domain und Standort bei Bedarf an:

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

Zertifikate und Schlüssel generieren

Nachdem die Datei vars eingerichtet wurde, kannst du mit den folgenden Befehlen die selbstsignierte Root-CA, das Server-Zertifikat, den privaten Schlüssel sowie optional eine Sperrliste erstellen:

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

Diese Skripte erzeugen die Dateien ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pem und server.crl.pem im Verzeichnis /etc/pki/taskd/.

Dateirechte und Eigentümer festlegen

Damit der TaskServer korrekt starten kann, müssen die Zugriffsrechte sowie die Besitzrechte der Zertifikatsdateien angepasst werden:

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

TaskServer aktivieren und starten

Aktiviere den Dienst, damit er beim Systemstart automatisch startet, und führe ihn anschließend sofort aus:

systemctl enable taskd
systemctl start taskd

Firewall-Port öffnen

Erlaube eingehenden Verkehr auf dem Standardport 53589/TCP für den TaskServer über firewalld:

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

Herzlichen Glückwunsch! TaskServer (taskd) wurde erfolgreich auf deinem CentOS 7 System installiert, konfiguriert und gestartet.

Schritt 8: TaskWarrior-Clientzertifikate erstellen und konfigurieren

Um eine sichere Verbindung zwischen dem TaskServer (taskd) und dem TaskWarrior-Client (task) herzustellen, musst du ein clientseitiges Zertifikat sowie einen privaten Schlüssel erzeugen. Dies ermöglicht eine verschlüsselte Datenübertragung.

Ein neues Client-Zertifikat erstellen

Führe den folgenden Befehl aus und ersetze NAME durch eine eindeutige Bezeichnung für das Gerät, auf dem der Client läuft:

generate.client NAME

Dieser Vorgang erzeugt die Dateien NAME.cert.pem und NAME.key.pem im Verzeichnis /etc/pki/taskd/.

Zertifikatsdateien ins Home-Verzeichnis kopieren

Übertrage das Client-Zertifikat, den privaten Schlüssel sowie das Root-CA-Zertifikat in das Home-Verzeichnis deines Benutzers. Ersetze joeqpublic durch deinen tatsächlichen Benutzernamen:

cp ca.cert.pem NAME.cert.pem NAME.key.pem /home/joeqpublic/
chown joeqpublic.joeqpublic /home/joeqpublic/*.pem
chmod 400 /home/joeqpublic/*.pem

Zertifikatsdateien als Archiv bündeln

Fasse alle drei PEM-Dateien zu einer ZIP-Datei zusammen, um sie einfacher auf den TaskWarrior-Client zu übertragen:

zip certficates.zip ca.cert.pem NAME.cert.pem NAME.key.pem

Du kannst anschließend scp auf der Kommandozeile oder ein grafisches Tool wie WinSCP verwenden, um die certficates.zip-Datei vom Server auf deinen lokalen Rechner, dein Notebook oder Smartphone herunterzuladen.

Root-Modus verlassen

Nachdem du alle Zertifikatsschritte abgeschlossen hast, beende den Root-Modus und fahre mit deinem regulären Benutzer fort:

exit

Damit ist deine TaskServer (taskd)-Installation bereit, sichere Verbindungen von TaskWarrior-Clients entgegenzunehmen.

Schritt 9: TaskWarrior unter Windows 10 installieren

Wenn du Windows 10 (Version 1607 oder neuer) verwendest, musst du das Windows-Subsystem für Linux (WSL) installieren, um TaskWarrior nutzen zu können.

Windows-Subsystem für Linux (WSL) aktivieren

Öffne zunächst PowerShell mit Administratorrechten. Drücke dazu die Windows-Taste, gib powershell ein, klicke mit der rechten Maustaste auf Windows PowerShell und wähle Als Administrator ausführen. Bestätige die Sicherheitsabfrage mit Ja.

Füge anschließend den folgenden Befehl in PowerShell ein, um WSL zu aktivieren. Nach Abschluss der Installation drücke Y, um den Rechner neu zu starten:

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

Ubuntu über WSL installieren

Nach dem Neustart öffne ein Eingabeaufforderungsfenster (Command Prompt) und gib folgenden Befehl ein, um die Installation von Ubuntu zu starten. Bestätige die Eingabeaufforderung mit Y. Ubuntu wird nun heruntergeladen und entpackt. Danach wirst du aufgefordert, einen Benutzernamen und ein Passwort zu vergeben:

bash

TaskWarrior installieren

Installiere TaskWarrior innerhalb der geöffneten Bash-Konsole mit folgendem Befehl:

sudo apt-get install task -y

Gib danach zweimal exit ein – einmal, um die Bash-Sitzung zu beenden, und ein zweites Mal, um das Eingabeaufforderungsfenster zu schließen.

Bash über die Taskleiste schnell starten

Klicke auf das Startmenü, gib ubuntu ein, klicke mit der rechten Maustaste auf Bash on Ubuntu on Windows und wähle An Taskleiste anheften, um schnellen Zugriff zu erhalten.

TaskWarrior-Konfiguration initialisieren

Klicke auf das neue Ubuntu-Symbol in der Taskleiste, um das Bash-Terminal zu öffnen. Initialisiere die Konfigurations- und Datenverzeichnisse von TaskWarrior mit folgendem Befehl:

task version
yes

Zertifikate übertragen und entpacken

Verschiebe die Datei certficates.zip, die du zuvor auf dem Server erstellt hast, in dein ~/.task/-Verzeichnis. Stelle sicher, dass das unzip-Paket installiert ist. Ersetze WINDOWSUSER mit deinem tatsächlichen Benutzernamen unter Windows:

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

TaskWarrior-Client für die Synchronisation konfigurieren

Führe die folgenden Befehle aus, um die Verbindung zu deinem TaskServer einzurichten. Ersetze die Platzhalter wie folgt:

• NAME: der Name des erstellten Client-Zertifikats
• GROUP: der erstellte Benutzergruppenname
• Joe Q. Public: dein registrierter Benutzername auf dem Server
• XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX: deine Benutzer-ID

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

TaskWarrior-Datenbank synchronisieren

Initialisiere abschließend die Synchronisationsdatenbank mit dem folgenden Befehl:

task sync init

TaskWarrior ist jetzt erfolgreich mit deinem TaskServer auf Windows 10 verbunden und synchronisiert.

Schritt 10: TaskWarrior auf Android einrichten

Um TaskWarrior auf einem Android-Gerät zu verwenden, musst du die dedizierte App TaskWarrior For Android aus dem Google Play Store installieren.

App über Google Play installieren

Lade die App TaskWarrior For Android direkt aus dem Play Store herunter und installiere sie auf deinem Gerät.

Erste Einrichtung in der App

Öffne die App. Wenn du zur Kontoerstellung aufgefordert wirst, gib denselben Benutzernamen ein, den du auch auf dem TaskServer angelegt hast. Belasse den Punkt Data Folder auf <<Create new>> und tippe anschließend auf OK.

Ordner für Zertifikate erstellen

Erstelle mit einem Datei-Manager einen Ordner im Hauptverzeichnis deines internen Speichers. Zum Beispiel:

/storage/emulated/0/Certs

Minimiere die TaskWarrior-App und entpacke die certificates.zip, die du vom Server auf dein Smartphone übertragen hast, in diesen Ordner.

Zertifikatsarchiv übertragen und entpacken

Verschiebe die Datei certificates.zip, die du beim Einrichten des TaskServers erstellt hast, in dein Benutzerverzeichnis. Installiere bei Bedarf das unzip-Paket über den Paketmanager deiner Linux-Distribution. Entpacke das Archiv anschließend im Verzeichnis ~/.task/. Passe den Pfad entsprechend an:

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

TaskWarrior mit TaskServer verbinden

Konfiguriere TaskWarrior so, dass er auf deine Zertifikate und den TaskServer zugreift. Ersetze die Platzhalter wie folgt:

• NAME: Name des Client-Zertifikats
• GROUP: erstellte Benutzergruppe
• Joe Q. Public: Benutzername auf dem Server
• XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX: deine Benutzer-ID vom TaskServer

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

Synchronisation mit TaskServer initialisieren

Führe folgenden Befehl aus, um deine lokale TaskWarrior-Datenbank mit dem Server zu verbinden und die Synchronisation zu starten:

task sync init

Optional: Gnome Shell Integration mit TaskWhisper

Falls du Gnome Shell verwendest, kannst du die Erweiterung TaskWhisper installieren. Diese bietet eine direkte Integration von TaskWarrior in deine Desktop-Umgebung.

TaskWarrior ist nun vollständig eingerichtet und synchronisiert sich erfolgreich mit deinem TaskServer auf deiner bevorzugten Linux-Distribution.

Fazit

Mit dieser Anleitung hast du ein sicheres und synchronisiertes Aufgabenverwaltungssystem auf Basis von TaskWarrior und TaskServer eingerichtet. Vom Serveraufbau unter CentOS 7 bis zur Einrichtung von Clients auf Windows, Android und Linux – jeder Schritt sorgt für eine verschlüsselte und plattformübergreifende Zusammenarbeit.

Diese Lösung ermöglicht dir, beliebig viele Aufgaben zu verwalten – mit voller Kontrolle, maximaler Datensicherheit und zuverlässiger Synchronisation. Egal ob du lieber im Terminal arbeitest oder unterwegs mit dem Smartphone – TaskWarrior bietet dir flexible Produktivität ohne Kompromisse.

Du bist nun bereit, deine Aufgaben effizienter und sicherer zu organisieren – mit einer leistungsstarken, quelloffenen Lösung für moderne Multi-Plattform-Umgebungen.