Nainstalujte TaskServer (taskd) na CentOS 7

TaskWarrior je open source nástroj pro správu času, který je vylepšením aplikace Todo.txt a jejích klonů. Vzhledem k tomu, že průměrný člověk používá ve svém denním rozvrhu více zařízení/platforem, je důležité mít možnost mít centralizované úložiště, kde lze k datům přistupovat a aktualizovat je z jakéhokoli zařízení. Tento výukový program se zaměří na nastavení serveru s názvem TaskServer (taskd) a klienta s názvem TaskWarrior (úloha), který umožňuje více klientským zařízením bezpečně přistupovat a vyměňovat si data.

Má následující vlastnosti:

• Neomezené úkoly
• Stanovení priorit úkolů
• Filtrování vyhledávání
• Označování
• Automatická synchronizace
• Automatické zálohování
• Plná kontrola a soukromí
• Šifrovaná komunikace

Předpoklady

• Instance serveru CentOS 7 x64.
• Uživatel sudo .
• Název domény odkazoval na instanci Vultr ( taskd.example.com )

Krok 1: Aktualizujte systém

Přihlaste se jako uživatel sudo, abyste si mohli nainstalovat úložiště EPEL a aktualizovat systém následovně:

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

Krok 2: Nainstalujte RPM Build a nástroje pro sestavení

Repozitář EPEL neobsahuje RPM pro TaskServer (taskd), takže jej musíme sestavit ze zdroje do balíčku RPM sami.

1. Nainstalujte nástroje GCC, Make, RPM Build, vývoj a podepisování.

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

2. Vytvořte adresář GnuPG, který bude obsahovat soubory GPG potřebné pro podepsání našeho RPM.

   mkdir .gnupg
   

3. Při vytváření klíče vyžadujeme v systému entropii, abychom jej správně randomizovali. rngdDémon vytváří entropie nutné z /dev/urandom. Tak to teď nainstalujme.

   yum install rngd -y
   

4. Spusťte rngddémona pro generování entropie. Volba -r ukazuje na /dev/urandommísto výchozího /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Vygenerujte klíč. Možnost --gen-key říká gpg, aby vygeneroval nový pár klíčů.

   gpg --gen-key
   

6. Pro možnost „ Vyberte prosím, jaký druh klíče chcete: “ vyberte jako typ klíče „ (1) RSA a RSA (výchozí) “ zadáním 1 a stisknutím klávesy Return/Enter .

7. U možnosti „ Jakou velikost klíče chcete? (2048) “ vyberte výchozí stisknutím klávesy Return/Enter .

8. U možnosti " Upřesněte, jak dlouho má být klíč platný. ", vyberte výchozí nastavení stisknutím klávesy Return/Enter .

9. Pro možnost „ Je to správné? (y/N) “ zadejte y a stiskněte klávesu Return/Enter .

10. Do pole „ Skutečné jméno: “ zadejte jméno podle svého výběru a stiskněte klávesu Return/Enter .

11. V části " E-mailová adresa: " zadejte e-mailovou adresu podle vlastního výběru a stiskněte klávesu Return/Enter .

12. Sekce Komentář: může být ponechána prázdná, pokud se tak rozhodnete.

13. Pokud jste své údaje nezadali správně, proveďte potřebné změny. Pokud jste se zobrazenými informacemi USER-ID spokojeni , zadejte O (velké písmeno O, nikoli nulu) a stiskněte klávesu Return/Enter .

14. GnuPG vás nyní vyzve k vytvoření a ověření hesla pro váš pár klíčů.

15. Poté, co zadáte svá hesla, bude váš pár klíčů GnuPG vytvořen v .gnupgadresáři ve vašem uživatelském adresáři.

16. Spuštěním tohoto příkazu zobrazíte obsah .gnupgadresáře. Měl by obsahovat následující adresář private-keys-v1.da soubory pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportujte vytvořený pár klíčů. Možnost --export dává GnuPG pokyn k exportu páru klíčů. Volba -a dává GnuPG pokyn k výstupu páru klíčů ve formátu ascii armor . Nahraďte " Joe Q. Public " jménem, ​​které jste zadali při vytváření páru klíčů v kroku č. 10 výše. Nahraďte " jqpublic " libovolným textem.

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

18. Importujte pár klíčů do úložiště klíčů RPM. Nahraďte „ jqpublic “ textem, který jste vybrali v kroku #17.

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

19. Ověřte, že byl pár klíčů přidán do úložiště klíčů RPM. Volba --q gpg-pubkey se dotazuje na úložiště klíčů RPM GnuPG. % {Name} -% {version} -% {release} -> {% souhrnné} \ n zobrazí výsledek v lidském čitelném formátu.

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

20. Vytvořením .rpmmacros file, lze RPM přizpůsobit tak, aby provádělo přiřazené chování (příklad: snadné automatické podepisování RPM). Pomocí nanoprogramu vytvořte soubor.

    nano .rpmmacros
    

21. Poté do .rpmmacrossouboru přidejte následující text .

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

22. Uložte dokument zadáním následujících kombinací klávesnice. Tyto CTRL + X Keys. Poté klávesa S. Nakonec klávesa Return/Enter .

23. Tento příkaz níže nastaví vaše prostředí sestavení RPM. Tím se k .rpmmacrossouboru, který jste vytvořili v kroku #20, připojí další makra a vytvoří se požadované adresáře pro sestavení a uložení RPM.

    rpmdev-setuptree
    

24. Spuštěním tohoto příkazu zobrazíte obsah adresáře rpmbuild. Měl by obsahovat následující adresáře SOURCES , RPMS , BUILD , SRPMS a SPECS .

    find rpmbuild
    

25. Stáhněte si zdrojový kód TaskServer (taskd) do rpmbuild/SOURCESadresáře.

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

26. Zabijte běžící rgndproces.

    sudo kill -9 rngd
    

Krok 3: Sestavte TaskServer (taskd) RPM ze zdroje

1. Aby bylo možné sestavit nový RPM ze zdroje, musí být vytvořen soubor SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Přidejte do taskd.specsouboru následující text níže .

   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. The RPM also requires three additional files that must be created in the rpmbuild/SOURCES directory. Use the nano program to create the taskd-config file.

   nano rpmbuild/SOURCES/taskd-config
   

4. Add the following text below into the taskd-config file.

   # 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. Use the nano program to create the taskd.service file.

   nano rpmbuild/SOURCES/taskd.service
   

6. Add the following text below into the taskd.service file.

   [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. Use the nano program to create the taskd.xml file.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Add the following text below into the taskd.xml file.

   <?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. In order to build the TaskServer (taskd) RPM, three packages are required for building. Run the command below to install those packages.

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

10. Now it is time to build from source and create an RPM for TaskServer (taskd). Run the commands below to get started. It should take less than a minute on a 1x CPU Vultr instance to build the RPMs. Enter the GnuPG password you created in step #14 to sign the RPM when prompted.

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

11. Install the TaskServer (taskd) RPM.

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

Step 4: Configure TaskServer (task)

1. In order for TaskServer (taskd) to communicate and sync with TaskWarrior (task) clients, you will need to use the generation scripts found under /etc/pki/taskd/ to generate server and client certificates/keys. Elevate to the root user using the command below and change directory to /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Use the nano program to create a vars file in order to generate a self-signed Root CA.

   nano vars
   

   Add the following text below into the vars file. Change ORGANIZATION, CN, COUNTRY, STATE and LOCALITY to your satisfaction.

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

3. Generate the self-signed Root CA, certificate, server key and server revocation list (optional).

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

   These commands will create the following files (ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pem and server.crl.pem) inside the /etc/pki/taskd/ directory. In order for TaskServer (taskd) to start, the ownership and permissions on the certificates and keys generated in step #37 must be modified to allow TaskServer (taskd) to access them. Run the commands below to change them.

   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. Enable and start the TaskServer (taskd) daemon.

   systemctl enable taskd
   systemctl start taskd
   

5. Open the port in the firewall TaskServer (taskd) runs on.

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

   TaskServer (taskd) is now installed and setup on your CentOS 7 instance.

Step 5: Configure TaskWarrior client certificate and key

1. You must create client certificates and key to encrypt communications between TaskServer (taskd) and TaskWarrior (task). Run the command below to generate a client certificate and key. Replace NAME with a name you can easily recognize for your client.

   generate.client NAME
   

   This command will create the following files (NAME.cert.pem, NAME.key.pem) inside of the /etc/pki/taskd/ directory.

2. Copy the following files to your user directory, change the ownership and permissions. Substitute joeqpublic below with your actual username directory.

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

3. Create a zip archive of the certificates and key.

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

4. Use scp (command line) or WinSCP (GUI frontend for SCP) to download the certificates.zip file from your CentOS instance to your client device (computer/laptop/smartphone).

5. Zrušte oprávnění root a provádějte zbytek příkazů jako běžný uživatel.

   exit
   

   TaskServer (taskd) je nyní nastaven a připraven pro připojení klientů TaskWarrior (task).

Krok 6: Vytvořte svou první skupinu TaskWarrior a uživatele

1. Abyste mohli vytvářet, mazat, upravovat a synchronizovat své úkoly, budete potřebovat uživatelský účet. Než však budete moci přidávat uživatele, musíte nejprve vytvořit organizační skupinu. Spusťte níže uvedený příkaz a vytvořte svou první skupinu. Nahraďte GROUP snadno rozpoznatelným názvem.

2. DŮLEŽITÉ! taskdPříkaz k vytvoření skupiny / Uživatelé musí být běžel jako taskduživatel. Spuštění jako uživatel root vytvoří adresáře a soubory vlastněné uživatelem root, pod /var/lib/taskd/orgskterými zabrání klientům TaskWarrior (úloh) v přístupu nebo úpravě čehokoli ve skupině, do které byli přiřazeni. Přístup bude odepřen.

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

3. Nyní, když jste vytvořili svou první skupinu, pojďme vytvořit prvního uživatele. Spuštěním níže uvedeného příkazu vytvořte uživatele přiřazeného ke skupině vytvořené v kroku #1. Zkopírujte a vložte vygenerovaný uživatelský klíč, uživatele a skupinu do textového souboru. Chcete-li přidat další uživatele, postup opakujte.

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

Krok 7: Nainstalujte klienty TaskWarrior

Windows 10 (sestavení novější než 1607+)

Chcete-li používat TaskWarrior (úkol) v systému Windows 10, musíte si z Windows Store nainstalovat Windows Subsystem For Linux .

1. K instalaci WSL je vyžadována zvýšená výzva Powershell. Stiskněte klávesu okna a zadejte powershell . Klikněte pravým tlačítkem na Windows Powershell v horní části výsledků a vyberte „ Spustit jako správce “. Ve výzvě Řízení uživatelských účtů klikněte na Ano . Zkopírujte a vložte text uvedený níže v oknech Powershell. Po dokončení instalace WSL stiskněte klávesu Y pro restartování systému Windows.

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

2. Po restartování otevřete příkazový řádek a zadejte následující příkaz bash . Tím se nainstaluje Ubuntu na Windows. Stiskněte tlačítko ý . Nyní bude stažen a extrahován. Vyberte uživatelské jméno a heslo.

   bash
   

3. Nyní je čas nainstalovat TaskWarrior (úkol). Do konzoly zadejte následující příkaz.

   sudo apt-get install task -y
   

4. Typ exit dvakrát pro odchod z bash terminálu a Windows příkazového řádku.

5. Klepněte na tlačítko Nabídka Start. Zadejte ubuntu . Klikněte pravým tlačítkem na Bash na Ubuntu ve Windows . Vyberte možnost Připnout na hlavní panel . To poskytuje pohodlí pro rychlý přístup k bash pro přístup k TaskWarrior (úloha).

6. Klikněte na ikonu Ubuntu, kterou jste právě vytvořili na hlavním panelu. Tím se otevře okno terminálu se systémem Bash. Zadejte následující příkaz níže a vytvořte datový adresář TaskWarrior (task) ( ~/.task/) a konfigurační soubor ( .taskrc).

   task version
   yes
   

7. certificates.zipSoubor, který jste uložili dříve během nastavení TaskServeru, musíte přesunout do ~/.taskd/adresáře uvnitř vašeho uživatelského adresáře. Chcete-li extrahovat soubory ze souboru zip, unzipnejprve nainstalujte program. Zkopírujte a vložte níže uvedené příkazy, kterými nahradíte skutečné umístění vaší kopie certificates.zip.

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

8. Zadejte následující příkazy pro nastavení TaskWarrior (task) pro připojení k TaskServeru (taskd). Nahraďte NAME tím, jak jste pojmenovali svůj certifikát a klíč, GROUP skupinou, kterou jste vytvořili, Joe Q. Public uživatelským jménem, ​​které jste vytvořili, a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX klíčem přiřazeným vašemu uživateli byl vytvořen na serveru TaskWarrior (taskd).

   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. Nyní je čas synchronizovat TaskWarrior (úloha) s TaskServer (taskd). Spusťte níže uvedený příkaz pro inicializaci databáze.

   task sync init
   

   Synchronizace mezi vaším TaskWarrior (task) klientem a TaskServerem (taskd) je nyní nastavena na platformě Windows 10.

Android

Chcete-li používat TaskWarrior (úkol) na Androidu, musíte si nainstalovat TaskWarrior pro Android z obchodu Google Play.

1. Nainstalujte si aplikaci TaskWarrior (úkol) pro Android z obchodu Google Play.

2. Otevřete aplikaci TaskWarrior (úkol) pro Android.

3. Aplikace vás vyzve k vytvoření účtu s požadovaným názvem účtu . Zadejte jméno, které jste zvolili při vytváření uživatelského jména pro uživatele TaskServer (taskd).

4. Ponechte datovou složku na výchozí nastavení <<Vytvořit nové>> a klepněte na tlačítko OK . Pomocí aplikace správce souborů vytvořte složku v kořenovém adresáři úložiště (například: /storage/emulate/0/Certs). Odešlete aplikaci na pozadí.

5. Zkopírujte certificates.zipsoubor, který jste vytvořili dříve, a extrahujte jeho obsah do adresáře vytvořeného v kroku #4.

6. V popředí aplikace „TaskWarrior (úkol) pro Android“ a klepnutím na nabídku v levém horním rohu aplikace ji otevřete.

7. Přejděte dolů do spodní části nabídky a klepněte na možnost Nastavení .

8. Tím se otevře jednoduchý vestavěný textový editor aplikace TaskWarrior pro Android.

9. Zadejte následující možnosti pro nastavení synchronizace s vaším TaskServerem (taskd). Nahraďte proměnné taskd.ca/ taskd.certificate/taskd.key` skutečnými cestami k adresáři ca/certificate/key, NAME tím, co jste pojmenovali svůj certifikát a klíč, GROUP skupinou, kterou jste vytvořili, Joe Q. Public vámi vytvořeným uživatelským jménem a XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s klíčem přiřazeným při vytváření uživatele na serveru TaskWarrior (taskd).

   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. Klepnutím na ikonu diskety uložíte nastavení.

Synchronizace mezi vaším TaskWarrior (task) klientem a TaskServerem (taskd) je nyní nastavena na platformě Android.

Linux

1. Informace o instalaci pro vaši konkrétní distribuci Linuxu naleznete v části distribuce TaskWarrior (task) .

2. Otevřete okno terminálu. Zadejte následující příkaz níže a vytvořte datový adresář TaskWarrior (task) ( ~/.task/) a konfigurační soubor ( .taskrc).

   task version
   yes
   

3. certificates.zipSoubor, který jste uložili dříve v nastavení TaskServeru, musíte přesunout do ~/.taskd/adresáře uvnitř vašeho uživatelského adresáře. Chcete-li extrahovat soubory ze souboru zip, nainstalujte unzipnejprve program pro vaši konkrétní distribuci. Zkopírujte a vložte následující příkazy níže a nahraďte skutečné umístění vaší kopie certificates.zip.

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

4. Zadejte následující příkazy pro nastavení TaskWarrior (task) pro připojení k TaskServeru (taskd). Nahraďte NAME tím, jak jste pojmenovali svůj certifikát a klíč, GROUP skupinou, kterou jste vytvořili, Joe Q. Public uživatelským jménem, ​​které jste vytvořili, a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX klíčem přiřazeným vašemu uživateli byl vytvořen na serveru TaskWarrior (taskd).

   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. Nyní je čas synchronizovat TaskWarrior (úloha) s TaskServer (taskd). Spusťte níže uvedený příkaz pro inicializaci databáze.

   task sync init
   

Dodatek: Pokud spustíte Gnome Shell, existuje rozšíření nazvané TaskWhisper, které se integruje s TaskWarrior (úloha).

Synchronizace mezi vaším TaskWarrior (task) klientem a TaskServerem (taskd) je nyní nastavena na vašem oblíbeném linuxovém distru.