Nainštalujte TaskServer (taskd) na CentOS 7

TaskWarrior je open source nástroj na správu času, ktorý je vylepšením aplikácie Todo.txt a jej klonov. Vzhľadom na skutočnosť, že priemerný človek používa vo svojom dennom rozvrhu viacero zariadení/platforiem, je dôležité mať možnosť mať centralizované úložisko, kde je možné pristupovať k údajom a aktualizovať ich z akéhokoľvek zariadenia. Tento tutoriál sa zameria na nastavenie servera s názvom TaskServer (taskd) a klienta s názvom TaskWarrior (úloha), ktorý umožňuje viacerým klientskym zariadeniam bezpečne pristupovať a vymieňať si údaje.

Má nasledujúce vlastnosti:

• Neobmedzené úlohy
• Uprednostňovanie úloh
• Filtrovanie vyhľadávania
• Označovanie
• Automatická synchronizácia
• Automatické zálohovanie
• Plná kontrola a súkromie
• Šifrovaná komunikácia

Predpoklady

• Inštancia servera CentOS 7 x64.
• Sudo používateľ.
• Názov domény ukázal na inštanciu Vultr ( taskd.example.com )

Krok 1: Aktualizujte systém

Prihláste sa ako používateľ sudo, aby ste si nainštalovali úložisko EPEL a aktualizovali systém nasledovne:

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

Krok 2: Nainštalujte RPM Build a nástroje na zostavovanie

Úložisko EPEL neobsahuje RPM pre TaskServer (taskd), takže ho musíme zostaviť zo zdroja do balíka RPM sami.

1. Nainštalujte nástroje GCC, Make, RPM Build, vývoj a podpisovanie.

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

2. Vytvorte adresár GnuPG, ktorý bude obsahovať súbory GPG potrebné na podpísanie nášho RPM.

   mkdir .gnupg
   

3. Pri vytváraní kľúča vyžadujeme v systéme entropiu, aby sme ho správne randomizovali. rngdDémon vytvára entropia nutné z /dev/urandom. Takže teraz to nainštalujeme.

   yum install rngd -y
   

4. Spustite rngddémona na generovanie entropie. Voľba -r ukazuje na /dev/urandomnamiesto predvoleného /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Vygenerujte kľúč. Voľba --gen-key povie gpg, aby vygeneroval nový pár kľúčov.

   gpg --gen-key
   

6. Pre možnosť „ Prosím vyberte, aký druh kľúča si želáte: “ vyberte ako typ kľúča „ (1) RSA a RSA (predvolené) “ zadaním 1 a stlačením klávesu Return/Enter .

7. Pre možnosť „ Akú veľkosť klávesu chcete? (2048) “ vyberte predvolenú hodnotu stlačením klávesu Return/Enter .

8. Pre možnosť " Uveďte, ako dlho má byť kľúč platný. ", vyberte predvolené nastavenie stlačením klávesu Return/Enter .

9. Pre možnosť „ Je to správne? (y/N) “ zadajte y a stlačte kláves Return/Enter .

10. Pod " Skutočné meno: " zadajte meno podľa vlastného výberu a stlačte kláves Return/Enter .

11. V časti " E-mailová adresa: " zadajte e-mailovú adresu podľa vlastného výberu a stlačte kláves Return/Enter .

12. Sekcia Komentár: môže zostať prázdna, ak sa tak rozhodnete.

13. Vykonajte potrebné zmeny, ak ste svoje informácie nezadali správne. Ak ste spokojní so zobrazenými informáciami USER-ID , zadajte O (veľké písmeno O, nie nulu) a stlačte kláves Return/Enter .

14. GnuPG vás teraz vyzve na vytvorenie a overenie hesla pre váš pár kľúčov.

15. Po zadaní hesiel sa váš pár kľúčov GnuPG vytvorí v .gnupgadresári vo vašom používateľskom adresári.

16. Spustite tento príkaz na zobrazenie obsahu .gnupgadresára. Mal by obsahovať nasledujúci adresár private-keys-v1.da súbory pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportujte vytvorený pár kľúčov. Voľba --export dáva pokyn GnuPG exportovať pár kľúčov. Voľba -a dáva pokyn GnuPG na výstup páru kľúčov vo formáte ascii armor . Nahraďte „ Joe Q. Public “ menom, ktoré ste zadali pri vytváraní páru kľúčov v kroku č. 10 vyššie. Nahraďte " jqpublic " ľubovoľným textom, ktorý si vyberiete.

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

18. Importujte pár kľúčov do úložiska kľúčov RPM. Nahraďte „ jqpublic “ textom, ktorý ste vybrali v kroku #17.

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

19. Overte, či bol pár kľúčov pridaný do skladu kľúčov RPM. Voľba --q gpg-pubkey sa pýta na úložisko kľúčov RPM GnuPG. % {Name} -% {version} -% {release} -> {% súhrnnej} \ n zobrazí výsledok v ľudskom čitateľnom formáte.

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

20. Vytvorením .rpmmacros file, možno RPM prispôsobiť tak, aby vykonávali priradené správanie (príklad: uľahčenie automatického podpisovania RPM). nanoNa vytvorenie súboru použite program.

    nano .rpmmacros
    

21. Potom do .rpmmacrossúboru pridajte nasledujúci text .

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

22. Uložte dokument zadaním nasledujúcich kombinácií klávesnice. Tieto CTRL + X Keys. Potom kláves S. Nakoniec kláves Return/Enter .

23. Tento príkaz nižšie nastaví vaše prostredie na zostavenie RPM. Tým sa k .rpmmacrossúboru, ktorý ste vytvorili v kroku č. 20, pridajú ďalšie makrá a vytvoria sa požadované adresáre na vytváranie a ukladanie RPM.

    rpmdev-setuptree
    

24. Spustite tento príkaz na zobrazenie obsahu adresára rpmbuild. Mal by obsahovať nasledujúce adresáre SOURCES , RPMS , BUILD , SRPMS a SPECS .

    find rpmbuild
    

25. Stiahnite si zdrojový kód TaskServer (taskd) do rpmbuild/SOURCESadresára.

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

26. Zabite spustený rgndproces.

    sudo kill -9 rngd
    

Krok 3: Zostavte TaskServer (taskd) RPM zo zdroja

1. Na vytvorenie nového RPM zo zdroja je potrebné vytvoriť súbor SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Do súboru pridajte nasledujúci text nižšie taskd.spec.

   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. Drop root privileges and perform the rest of your commands as your regular user.

   exit
   

   TaskServer (taskd) is now setup and ready for TaskWarrior (task) clients to connect.

Step 6: Create your first TaskWarrior group and user

1. In order to create, delete, modify and sync your tasks, you will need a user account. However, before you can add users, you will first need to create an organizational group. Run the command below to create your first group. Replace GROUP with an easily recognizable name.

2. IMPORTANT! The taskd command to create groups/users must be ran as the taskd user. Running as the root user will create directories and files owned by the root user under /var/lib/taskd/orgs which will prevent TaskWarrior (task) clients from being able to access or modify anything in the group to which they have been assigned. Access will be denied.

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

3. Now, that you've created your first group, let's create your first user. Run the command below to create a user assigned to the group created in step #1. Copy and paste the generated user key, user and group in a text file. Repeat the process to add additional users.

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

Step 7: Install TaskWarrior clients

Windows 10 (Build later than 1607+)

To use TaskWarrior (task) on Windows 10, you need to install the Windows Subsystem For Linux from the Windows Store.

1. To install WSL, an elevated Powershell prompt is required. Press the Window Key and type powershell. Right click on Windows Powershell at the top of the results and select "Run as administrator". At the User Account Control prompt, click Yes. Copy and paste the text found below in the Powershell windows. When WSL finishes installing, press the Y Key to restart Windows.

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

2. After rebooting, open a command prompt and type the following command bash. This will install Ubuntu on Windows. Press the Y Key. It will now be downloaded and extracted. Choose a username and password.

   bash
   

3. Now it's time to install TaskWarrior (task). Type the following command inside the console.

   sudo apt-get install task -y
   

4. Type exit twice to exit out of bash terminal and the Windows command prompt.

5. Click the Start Menu button. Type ubuntu. Right click on Bash on Ubuntu on Windows. Select Pin to taskbar. This provides convenience to quickly access bash to access TaskWarrior (task).

6. Click on the Ubuntu icon you have just created on the taskbar. This will open a terminal window running Bash. Type the following command below to create TaskWarrior (task) data directory (~/.task/) and configuration file (.taskrc).

   task version
   yes
   

7. You need to move the certificates.zip file you've saved earlier during the TaskServer setup into the ~/.taskd/ directory inside of your user directory. To extract the files from the zip file, install the unzip program first. Copy and paste the following commands below substituting the actual location of your copy of certificates.zip.

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

8. Zadajte nasledujúce príkazy na nastavenie TaskWarrior (úloha), aby sa pripojil k serveru TaskServer (taskd). Nahraďte NAME tým, ako ste pomenovali svoj certifikát a kľúč, GROUP skupinou, ktorú ste vytvorili, Joe Q. Public užívateľským menom, ktoré ste vytvorili a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX kľúčom priradeným, keď váš užívateľ bol vytvorený na serveri 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. Teraz je čas na synchronizáciu TaskWarrior (úloha) s TaskServer (taskd). Spustite príkaz uvedený nižšie na inicializáciu databázy.

   task sync init
   

   Synchronizácia medzi vašim TaskWarrior (úloha) klientom a TaskServer (taskd) je teraz nastavená na platforme Windows 10.

Android

Ak chcete používať TaskWarrior (úlohu) v systéme Android, musíte si nainštalovať TaskWarrior pre Android z obchodu Google Play.

1. Nainštalujte si aplikáciu TaskWarrior (úloha) pre Android v obchode Google Play.

2. Otvorte aplikáciu TaskWarrior (úloha) pre Android.

3. Aplikácia vás vyzve na vytvorenie účtu s požadovaným názvom účtu . Zadajte meno, ktoré ste si vybrali pri vytváraní používateľského mena pre používateľa TaskServer (taskd).

4. Ponechajte priečinok s údajmi na predvolené nastavenie <<Vytvoriť nový>> a klepnite na tlačidlo OK . Pomocou aplikácie správcu súborov vytvorte priečinok v koreňovom adresári úložiska (napríklad: /storage/emulate/0/Certs). Pošlite aplikáciu na pozadie.

5. Skopírujte certificates.zipsúbor, ktorý ste predtým vytvorili, a extrahujte jeho obsah do svojho adresára vytvoreného v kroku #4.

6. V popredí aplikácie „TaskWarrior (úloha) pre Android“ a klepnutím na ponuku v ľavom hornom rohu aplikácie ju otvorte.

7. Prejdite nadol do spodnej časti ponuky a klepnite na možnosť Nastavenia .

8. Tým sa otvorí jednoduchý vstavaný textový editor aplikácie TaskWarrior For Android.

9. Zadajte nasledujúce možnosti na nastavenie synchronizácie s vaším TaskServerom (taskd). Nahraďte premenné taskd.ca/ taskd.certificate/taskd.key` skutočnými cestami k adresáru ca/certificate/key, NAME tým, čo ste nazvali váš certifikát a kľúč, GROUP skupinou, ktorú ste vytvorili, Joe Q. Public užívateľským menom, ktoré ste vytvorili a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX s kľúčom priradeným pri vytváraní používateľa na serveri 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 nastavenia.

Synchronizácia medzi vašim TaskWarrior (úloha) klientom a TaskServer (taskd) je teraz nastavená na platforme Android.

Linux

1. Informácie o inštalácii pre vašu konkrétnu distribúciu Linuxu nájdete v sekcii distribúcie TaskWarrior (úloha) .

2. Otvorte okno terminálu. Zadajte nasledujúci príkaz nižšie na vytvorenie adresára údajov TaskWarrior (úloha) ( ~/.task/) a konfiguračného súboru ( .taskrc).

   task version
   yes
   

3. Musíte presunúť certificates.zipsúbor, ktorý ste predtým uložili v nastavení TaskServer, do ~/.taskd/adresára vo vašom používateľskom adresári. Ak chcete extrahovať súbory zo súboru zip, unzipnajskôr nainštalujte program pre vašu konkrétnu distribúciu. Skopírujte a prilepte nasledujúce príkazy nižšie, pričom nahraďte skutočné umiestnenie vašej kópie súboru certificates.zip.

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

4. Zadajte nasledujúce príkazy na nastavenie TaskWarrior (úloha), aby sa pripojil k serveru TaskServer (taskd). Nahraďte NAME tým, ako ste pomenovali svoj certifikát a kľúč, GROUP skupinou, ktorú ste vytvorili, Joe Q. Public užívateľským menom, ktoré ste vytvorili a XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX kľúčom priradeným, keď váš užívateľ bol vytvorený na serveri 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. Teraz je čas na synchronizáciu TaskWarrior (úloha) s TaskServer (taskd). Spustite príkaz uvedený nižšie na inicializáciu databázy.

   task sync init
   

Dodatok: Ak spustíte Gnome Shell, existuje rozšírenie s názvom TaskWhisper, ktoré sa integruje s TaskWarrior (úloha).

Synchronizácia medzi vašim TaskWarrior (úloha) klientom a TaskServer (taskd) je teraz nastavená vo vašej obľúbenej linuxovej distribúcii.