Installieren Sie TaskServer (taskd) unter CentOS 7

TaskWarrior ist ein Open Source-Zeitmanagement-Tool, das eine Verbesserung der Todo.txt-Anwendung und ihrer Klone darstellt. Aufgrund der Tatsache, dass die durchschnittliche Person mehrere Geräte / Plattformen in ihrem täglichen Zeitplan verwendet, ist es wichtig, über ein zentrales Repository zu verfügen, in dem von jedem Gerät aus auf die Daten zugegriffen und diese aktualisiert werden können. Dieses Lernprogramm konzentriert sich auf das Einrichten des Servers mit dem Namen TaskServer (taskd) und des Clients mit dem Namen TaskWarrior (task), sodass mehrere Clientgeräte sicher auf Daten zugreifen und diese austauschen können.

Es hat die folgenden Funktionen:

• Unbegrenzte Aufgaben
• Aufgabenpriorisierung
• Suchfilterung
• Markieren
• Automatische Synchronisierung
• Automatische Sicherung
• Volle Kontrolle und Privatsphäre
• Verschlüsselte Kommunikation

Voraussetzungen

• Eine CentOS 7 x64-Serverinstanz.
• Ein Sudo- Benutzer.
• Der Domänenname zeigte auf eine Vultr-Instanz (taskd.example.com).

Schritt 1: Aktualisieren Sie das System

Melden Sie sich als Ihr sudo-Benutzer an, um das EPEL-Repository zu installieren und das System wie folgt zu aktualisieren:

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

Schritt 2: Installieren Sie RPM Build und Tools zum Erstellen

Das EPEL-Repository enthält kein RPM für den TaskServer (taskd), daher müssen wir es selbst aus dem Quellcode in ein RPM-Paket einbauen.

1. Installieren Sie die Tools GCC, Make, RPM Build, Development und Signing.

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

2. Erstellen Sie ein GnuPG-Verzeichnis, das die GPG-Dateien enthält, die zum Signieren unseres RPM erforderlich sind.

   mkdir .gnupg
   

3. Beim Erstellen eines Schlüssels benötigen wir Entropie im System, um ihn richtig zufällig zu ordnen. Der rngdDaemon generiert die erforderliche Entropie aus /dev/urandom. Lassen Sie uns das jetzt installieren.

   yum install rngd -y
   

4. Starten Sie den rngdDaemon, um Entropie zu generieren. Die Option -r zeigt auf /dev/urandomanstelle der Standardeinstellung /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generieren Sie einen Schlüssel. Die Option --gen-key weist gpg an, ein neues Schlüsselpaar zu generieren.

   gpg --gen-key
   

6. Wählen Sie für die Option " Bitte wählen Sie die gewünschte Art von Schlüssel aus: " die Option " (1) RSA und RSA (Standard) " für den Schlüsseltyp aus, indem Sie 1 eingeben und die Eingabetaste drücken.

7. Wählen Sie für die Option " Welche Tastengröße möchten Sie? (2048) " die Standardeinstellung aus, indem Sie die Eingabetaste drücken.

8. Wählen Sie für die Option " Bitte geben Sie an, wie lange die Taste gültig sein soll " die Standardeinstellung durch Drücken der Eingabetaste .

9. Geben Sie für die Option " Ist das richtig? (J / N) " y ein und drücken Sie die Eingabetaste .

10. Geben Sie unter " Realer Name: " einen Namen Ihrer Wahl ein und drücken Sie die Eingabetaste .

11. Geben Sie unter " E-Mail-Adresse: " eine E-Mail-Adresse Ihrer Wahl ein und drücken Sie die Eingabetaste .

12. Der Abschnitt Kommentar: kann leer gelassen werden, wenn Sie dies wünschen.

13. Nehmen Sie die erforderlichen Änderungen vor, wenn Sie Ihre Daten nicht korrekt eingegeben haben. Wenn Sie mit den angezeigten USER-ID- Informationen zufrieden sind , geben Sie O (Großbuchstabe O, nicht Null) ein und drücken Sie die Eingabetaste .

14. GnuPG fordert Sie nun auf, ein Kennwort für Ihr Schlüsselpaar zu erstellen und zu überprüfen.

15. Nachdem Sie Ihre Passwörter eingegeben haben, wird Ihr GnuPG-Schlüsselpaar unter dem .gnupgVerzeichnis in Ihrem Benutzerverzeichnis erstellt.

16. Führen Sie diesen Befehl aus, um den Inhalt des .gnupgVerzeichnisses anzuzeigen . Es soll das folgende Verzeichnis enthält private-keys-v1.dund Dateien pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportieren Sie das erstellte Schlüsselpaar. Die Option --export weist GnuPG an, das Schlüsselpaar zu exportieren. Die Option -a weist GnuPG an, das Schlüsselpaar im ASCII-Rüstungsformat auszugeben . Ersetzen Sie " Joe Q. Public " durch den Namen, den Sie beim Erstellen des Schlüsselpaars in Schritt 10 oben eingegeben haben. Ersetzen Sie " jqpublic " durch einen beliebigen Text.

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

18. Importieren Sie das Schlüsselpaar in den RPM-Keystore. Ersetzen Sie die " jqpublic " durch den in Schritt 17 ausgewählten Text.

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

19. Stellen Sie sicher, dass das Schlüsselpaar zum RPM-Keystore hinzugefügt wurde. Die Option --q gpg-pubkey fragt den RPM-GnuPG-Keystore ab. Das % {name} -% {version} -% {release} ->% {summary} \ n zeigt das Ergebnis in einem für Menschen lesbaren Format an.

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

20. Durch das Erstellen von .rpmmacros filekann RPM angepasst werden, um zugewiesene Verhaltensweisen auszuführen (Beispiel: Vereinfachen Sie das automatische Signieren von RPMs). Verwenden Sie das nanoProgramm, um die Datei zu erstellen.

    nano .rpmmacros
    

21. Fügen Sie dann den folgenden Text in die .rpmmacrosDatei ein.

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

22. Speichern Sie das Dokument, indem Sie die folgenden Tastaturkombinationen eingeben. Die STRG + X- Tasten. Dann die S- Taste. Zum Schluss die Return / Enter- Taste.

23. Dieser Befehl unten richtet Ihre RPM-Build-Umgebung ein. Dadurch werden zusätzliche Makros an die .rpmmacrosDatei angehängt, die Sie in Schritt 20 erstellt haben, und die erforderlichen Verzeichnisse zum Erstellen und Speichern von RPMs erstellt.

    rpmdev-setuptree
    

24. Führen Sie diesen Befehl aus, um den Inhalt des Verzeichnisses rpmbuild anzuzeigen. Es sollte die folgenden Verzeichnisse enthalten QUELLEN , RPMS , BUILD , SRPMS und SPECS .

    find rpmbuild
    

25. Laden Sie den TaskServer (taskd) -Quellcode in das rpmbuild/SOURCESVerzeichnis herunter .

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

26. Beenden Sie den laufenden rgndProzess.

    sudo kill -9 rngd
    

Schritt 3: Erstellen Sie das TaskServer-RPM (taskd) aus dem Quellcode

1. Um ein neues RPM aus dem Quellcode zu erstellen, muss eine TaskServer (taskd) SPEC-Datei erstellt werden.

   nano rpmbuild/SPECS/taskd.spec
   

2. Fügen Sie der taskd.specDatei den folgenden Text hinzu .

   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
   # On rhel, we don't need systemd to build.  but we do on centos.        
   # ...just to define some macros
   %else
   BuildRequires:  systemd
   %endif
   
   # For certificate generation        
   Requires:       gnutls-utils
   
   # Systemd requires
   Requires(post):    systemd
   Requires(preun):   systemd
   Requires(postun):  systemd
   
   %description
   The TaskServer is a lightweight, secure server providing multi-user,
   multi-client access to task data.  This allows true syncing between desktop and
   mobile clients.
   
   Users want task list access from multiple devices running software of differing
   sophistication levels to synchronize data seamlessly.  Synchronization requires
   the ability to exchange transactions between devices that may not have
   continuous connectivity, and may not have feature parity.
   
   The TaskServer provides this and builds a framework to go several steps beyond
   merely synchronizing data.
   
   %prep
   %setup -q %{name}-%{version}
   
   %build
   %cmake
   make %{?_smp_mflags}
   
   %install
   make install DESTDIR=%{buildroot}
   
   mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
   
   # Users will keep their keys here, but we copy some helpful scripts too.
   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 and earlier needs a sysvinit script
   # Also, no firewalld on old EL
   %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 scriptlets
   %if 0%{?rhel} && 0%{?rhel} <= 6
   # No systemd for 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
   # No sysvinit files for el6
   %else
   %{_unitdir}/taskd.service
   %{_prefix}/lib/firewalld/services/taskd.xml
   %endif
   
   %changelog
   * Thu Aug 17 2017 Jarrett Graham <[email protected]> - 1.1.0
   - Initial packaging.
   

3. Das RPM erfordert außerdem drei zusätzliche Dateien, die im rpmbuild/SOURCESVerzeichnis erstellt werden müssen. Verwenden Sie das nanoProgramm, um die taskd-configDatei zu erstellen .

   nano rpmbuild/SOURCES/taskd-config
   

4. Fügen Sie der taskd-configDatei den folgenden Text hinzu .

   # taskd configuration file
   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
   

5. Verwenden Sie das nanoProgramm, um die taskd.serviceDatei zu erstellen .

   nano rpmbuild/SOURCES/taskd.service
   

6. Fügen Sie der taskd.serviceDatei den folgenden Text hinzu .

   [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
   

7. Verwenden Sie das nanoProgramm, um die taskd.xmlDatei zu erstellen .

   nano rpmbuild/SOURCES/taskd.xml
   

8. Fügen Sie der taskd.xmlDatei den folgenden Text hinzu .

   <?xml version="1.0" encoding="utf-8"?>
   <service>
     <short>Task-warrior server</short>
     <description>This option allows you to connect to the task warrior server.</description>
     <port protocol="tcp" port="53589"/>
   </service>
   

9. Zum Erstellen des TaskServer (taskd) RPM sind drei Pakete zum Erstellen erforderlich. Führen Sie den folgenden Befehl aus, um diese Pakete zu installieren.

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

10. Jetzt ist es Zeit, aus dem Quellcode zu erstellen und ein RPM für TaskServer (taskd) zu erstellen. Führen Sie die folgenden Befehle aus, um loszulegen. Das Erstellen der RPMs sollte auf einer 1x CPU Vultr-Instanz weniger als eine Minute dauern. Geben Sie das GnuPG-Passwort ein, das Sie in Schritt 14 erstellt haben, um die Drehzahl zu signieren, wenn Sie dazu aufgefordert werden.

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

11. Installieren Sie das TaskServer (taskd) RPM.

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

Schritt 4: TaskServer konfigurieren (Task)

1. Damit TaskServer (taskd) mit TaskWarrior (task) -Clients kommunizieren und synchronisieren kann, müssen Sie die unter aufgeführten /etc/pki/taskd/Generierungsskripts verwenden, um Server- und Clientzertifikate / -schlüssel zu generieren. Erhöhen Sie den Root-Benutzer mit dem folgenden Befehl und wechseln Sie in das Verzeichnis /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Verwenden Sie das nanoProgramm, um eine varsDatei zu erstellen , um eine selbstsignierte Stammzertifizierungsstelle zu generieren.

   nano vars
   

   Fügen Sie den folgenden Text in die Vars-Datei ein. Ändern Sie ORGANISATION , CN , LAND , STAAT und LOKALITÄT zu Ihrer Zufriedenheit.

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

3. Generieren Sie die selbstsignierte Stammzertifizierungsstelle, das Zertifikat, den Serverschlüssel und die Server-Sperrliste (optional).

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

   Diese Befehle erstellen die folgenden Dateien ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemund server.crl.pem) innerhalb des /etc/pki/taskd/Verzeichnisses. Damit TaskServer (taskd) gestartet werden kann, müssen der Besitz und die Berechtigungen für die in Schritt 37 generierten Zertifikate und Schlüssel geändert werden, damit TaskServer (taskd) auf sie zugreifen kann. Führen Sie die folgenden Befehle aus, um sie zu ändern.

   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
   

4. Aktivieren und starten Sie den TaskServer (taskd) -Dämon.

   systemctl enable taskd
   systemctl start taskd
   

5. Öffnen Sie den Port in der Firewall, auf der TaskServer (taskd) ausgeführt wird.

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

   TaskServer (taskd) ist jetzt auf Ihrer CentOS 7-Instanz installiert und eingerichtet.

Schritt 5: Konfigurieren Sie das TaskWarrior-Clientzertifikat und den Schlüssel

1. Sie müssen Client-Zertifikate und Schlüssel erstellen, um die Kommunikation zwischen TaskServer (taskd) und TaskWarrior (task) zu verschlüsseln. Führen Sie den folgenden Befehl aus, um ein Client-Zertifikat und einen Schlüssel zu generieren. Ersetzen Sie NAMEdurch einen Namen, den Sie für Ihren Kunden leicht erkennen können.

   generate.client NAME
   

   Dieser Befehl erstellt die folgenden Dateien ( NAME.cert.pem, NAME.key.pem) im /etc/pki/taskd/Verzeichnis.

2. Kopieren Sie die folgenden Dateien in Ihr Benutzerverzeichnis, ändern Sie den Besitz und die Berechtigungen. Ersetzen Sie joeqpublic unten durch Ihr aktuelles Benutzernamenverzeichnis.

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

3. Erstellen Sie ein Zip-Archiv der Zertifikate und des Schlüssels.

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

4. Verwenden Sie scp(Befehlszeile) oder WinSCP (GUI-Frontend für SCP), um die certificates.zipDatei von Ihrer CentOS-Instanz auf Ihr Client-Gerät (Computer / Laptop / Smartphone) herunterzuladen .

5. Löschen Sie Root-Berechtigungen und führen Sie den Rest Ihrer Befehle als regulärer Benutzer aus.

   exit
   

   TaskServer (taskd) ist jetzt eingerichtet und bereit, damit TaskWarrior (task) -Clients eine Verbindung herstellen können.

Schritt 6: Erstellen Sie Ihre erste TaskWarrior-Gruppe und Ihren ersten Benutzer

1. Zum Erstellen, Löschen, Ändern und Synchronisieren Ihrer Aufgaben benötigen Sie ein Benutzerkonto. Bevor Sie jedoch Benutzer hinzufügen können, müssen Sie zunächst eine Organisationsgruppe erstellen. Führen Sie den folgenden Befehl aus, um Ihre erste Gruppe zu erstellen. Ersetzen Sie GROUP durch einen leicht erkennbaren Namen.

2. WICHTIG! Der taskdBefehl zum Erstellen von Gruppen / Benutzern muss als taskdBenutzer ausgeführt werden. Wenn Sie als Root-Benutzer ausgeführt werden, werden Verzeichnisse und Dateien erstellt, deren Eigentümer der Root-Benutzer ist. /var/lib/taskd/orgsDadurch wird verhindert, dass TaskWarrior-Clients (Task-Clients) auf Elemente in der Gruppe zugreifen oder diese ändern können, denen sie zugewiesen wurden. Der Zugang wird verweigert.

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

3. Nachdem Sie Ihre erste Gruppe erstellt haben, erstellen wir Ihren ersten Benutzer. Führen Sie den folgenden Befehl aus, um einen Benutzer zu erstellen, der der in Schritt 1 erstellten Gruppe zugewiesen ist. Kopieren Sie den generierten Benutzerschlüssel, Benutzer und die Gruppe und fügen Sie sie in eine Textdatei ein. Wiederholen Sie den Vorgang, um weitere Benutzer hinzuzufügen.

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

Schritt 7: Installieren Sie TaskWarrior-Clients

Windows 10 (Build später als 1607+)

Um TaskWarrior (Task) unter Windows 10 verwenden zu können, müssen Sie das Windows-Subsystem für Linux aus dem Windows Store installieren .

1. Zum Installieren von WSL ist eine erhöhte Powershell-Eingabeaufforderung erforderlich. Drücken Sie die Fenstertaste und geben Sie Powershell ein . Klicken Sie oben in den Ergebnissen mit der rechten Maustaste auf Windows Powershell und wählen Sie " Als Administrator ausführen ". Klicken Sie an der Eingabeaufforderung zur Benutzerkontensteuerung auf Ja . Kopieren Sie den unten stehenden Text und fügen Sie ihn in die Powershell-Fenster ein. Wenn die Installation von WSL abgeschlossen ist, drücken Sie die Y-Taste , um Windows neu zu starten.

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

2. Öffnen Sie nach dem Neustart eine Eingabeaufforderung und geben Sie die folgende Befehls- Bash ein . Dadurch wird Ubuntu unter Windows installiert. Drücken Sie die Y-Taste . Es wird nun heruntergeladen und extrahiert. Wählen Sie einen Benutzernamen und ein Passwort.

   bash
   

3. Jetzt ist es Zeit, TaskWarrior (Task) zu installieren. Geben Sie den folgenden Befehl in die Konsole ein.

   sudo apt-get install task -y
   

4. Typ exit zweimal beenden aus bash - Terminal und die Windows - Eingabeaufforderung.

5. Klicken Sie auf die Schaltfläche Startmenü. Geben Sie ubuntu ein . Klicken Sie mit der rechten Maustaste auf Bash unter Ubuntu unter Windows . Wählen Sie An Taskleiste anheften . Dies bietet Komfort für den schnellen Zugriff auf Bash, um auf TaskWarrior (Task) zuzugreifen.

6. Klicken Sie in der Taskleiste auf das gerade erstellte Ubuntu-Symbol. Dies öffnet ein Terminalfenster, in dem Bash ausgeführt wird. Geben Sie den folgenden Befehl ein, um das TaskWarrior (Task) -Datenverzeichnis ( ~/.task/) und die Konfigurationsdatei ( .taskrc) zu erstellen .

   task version
   yes
   

7. Sie müssen certificates.zipdie zuvor während des TaskServer-Setups gespeicherte Datei in das ~/.taskd/Verzeichnis in Ihrem Benutzerverzeichnis verschieben. Installieren Sie zuerst das unzipProgramm , um die Dateien aus der Zip-Datei zu extrahieren . Kopieren Sie die folgenden Befehle und fügen Sie sie ein, wobei Sie den tatsächlichen Speicherort Ihrer Kopie von ersetzen certificates.zip.

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

8. Geben Sie die folgenden Befehle ein, um TaskWarrior (task) für die Verbindung mit TaskServer (taskd) einzurichten. Ersetzen Sie NAME durch das, was Sie als Zertifikat und Schlüssel bezeichnet haben, GROUP durch die von Ihnen erstellte Gruppe, Joe Q. Public durch den von Ihnen erstellten Benutzernamen und XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX durch den Schlüssel, den Ihr Benutzer zugewiesen hat wurde auf dem TaskWarrior-Server (taskd) erstellt.

   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
   

9. Jetzt ist es Zeit, TaskWarrior (Task) mit TaskServer (Taskd) zu synchronisieren. Führen Sie den folgenden Befehl aus, um die Datenbank zu initialisieren.

   task sync init
   

   Die Synchronisierung zwischen Ihrem TaskWarrior-Client (Task-Client) und dem TaskServer (TaskD) wird jetzt auf der Windows 10-Plattform eingerichtet.

Android

Um TaskWarrior (Task) unter Android zu verwenden, müssen Sie TaskWarrior für Android aus dem Google Play Store installieren .

1. Installieren Sie die TaskWarrior (Task) für Android-App im Google Play Store.

2. Öffnen Sie die App TaskWarrior (Aufgabe) für Android.

3. Sie werden von der App aufgefordert, ein Konto mit einem gewünschten Kontonamen zu erstellen . Geben Sie den Namen ein, den Sie beim Erstellen eines Benutzernamens für einen TaskServer-Benutzer (taskd) ausgewählt haben.

4. Belassen Sie den Datenordner auf der Standardeinstellung << Neu erstellen >> und tippen Sie auf die Schaltfläche OK . Verwenden Sie eine Dateimanager-App, um einen Ordner in Ihrem Speicherstamm zu erstellen (zum Beispiel :) /storage/emulate/0/Certs. Senden Sie die App in den Hintergrund.

5. Kopieren certificates.zipSie die zuvor erstellte Datei und extrahieren Sie ihren Inhalt in das in Schritt 4 erstellte Verzeichnis.

6. Stellen Sie die App "TaskWarrior (Aufgabe) für Android" in den Vordergrund und tippen Sie auf das Menü in der oberen linken Ecke der App, um sie zu öffnen.

7. Scrollen Sie zum Ende des Menüs und tippen Sie auf die Option Einstellungen .

8. Dadurch wird ein einfacher integrierter TaskWarrior für Android-App-Texteditor geöffnet.

9. Geben Sie die folgenden Optionen ein, um die Synchronisierung mit Ihrem TaskServer (taskd) einzurichten. Ersetzen Sie die Variablen taskd.ca/ taskd.certificate/ taskd.key` durch die tatsächlichen Verzeichnispfade ca / ​​certificate / key, NAME durch den Namen Ihres Zertifikats und Schlüssels, GROUP durch die von Ihnen erstellte Gruppe, Joe Q. Public durch den von Ihnen erstellten Benutzernamen und XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX mit dem Schlüssel, der beim Erstellen Ihres Benutzers auf dem TaskWarrior-Server (taskd) zugewiesen wurde.

   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
   

10. Tippen Sie auf das Diskettensymbol, um Ihre Einstellungen zu speichern.

Die Synchronisierung zwischen Ihrem TaskWarrior-Client (Task-Client) und dem TaskServer (TaskD) wird jetzt auf der Android-Plattform eingerichtet.

Linux

1. Informationen zur Installation Ihrer Linux-Distribution finden Sie im Abschnitt TaskWarrior (Task) -Distribution .

2. Öffnen Sie ein Terminalfenster. Geben Sie den folgenden Befehl ein, um das TaskWarrior (Task) -Datenverzeichnis ( ~/.task/) und die Konfigurationsdatei ( .taskrc) zu erstellen .

   task version
   yes
   

3. Sie müssen certificates.zipdie zuvor im TaskServer-Setup gespeicherte Datei in das ~/.taskd/Verzeichnis in Ihrem Benutzerverzeichnis verschieben. Um die Dateien aus der Zip-Datei zu extrahieren, installieren Sie zuerst das unzipProgramm für Ihre bestimmte Distribution. Kopieren Sie die folgenden Befehle und fügen Sie sie ein. Ersetzen Sie dabei den tatsächlichen Speicherort Ihrer Kopie von certificates.zip.

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

4. Geben Sie die folgenden Befehle ein, um TaskWarrior (task) für die Verbindung mit TaskServer (taskd) einzurichten. Ersetzen Sie NAME durch das, was Sie als Zertifikat und Schlüssel bezeichnet haben, GROUP durch die Gruppe, die Sie erstellt haben, Joe Q. Public durch den von Ihnen erstellten Benutzernamen und XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX durch den Schlüssel, den Ihr Benutzer zugewiesen hat wurde auf dem TaskWarrior-Server (taskd) erstellt.

   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
   

5. Jetzt ist es Zeit, TaskWarrior (Task) mit TaskServer (Taskd) zu synchronisieren. Führen Sie den folgenden Befehl aus, um die Datenbank zu initialisieren.

   task sync init
   

Nachtrag: Wenn Sie Gnome Shell ausführen, gibt es eine Erweiterung namens TaskWhisper , die in TaskWarrior (Task) integriert ist.

Die Synchronisierung zwischen Ihrem TaskWarrior (Task) -Client und dem TaskServer (Taskd) wird jetzt in Ihrer bevorzugten Linux-Distribution eingerichtet.