Instal·leu TaskServer (taskd) a CentOS 7

TaskWarrior és una eina de gestió del temps de codi obert que és una millora de l'aplicació Todo.txt i els seus clons. A causa del fet que la persona mitjana utilitza diversos dispositius/plataformes a la seva programació diària, és fonamental tenir la possibilitat de tenir un repositori centralitzat on es pugui accedir i actualitzar les dades des de qualsevol dispositiu. Aquest tutorial se centrarà a configurar tant el servidor, anomenat TaskServer (taskd), com el client, anomenat TaskWarrior (task), permetent que diversos dispositius client accedeixin i intercanviïn dades de manera segura.

Té les següents característiques:

• Tasques il·limitades
• Priorització de tasques
• Filtrat de cerca
• Etiquetatge
• Sincronització automàtica
• Còpia de seguretat automàtica
• Control total i privadesa
• Comunicació xifrada

Requisits previs

• Una instància de servidor CentOS 7 x64.
• Un usuari de sudo .
• El nom de domini apunta a una instància de Vultr (taskd.example.com)

Pas 1: actualitzeu el sistema

Inicieu sessió com a usuari de sudo per instal·lar el repositori EPEL i actualitzar el sistema de la següent manera:

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

Pas 2: instal·leu RPM Build i les eines per a la construcció

El repositori EPEL no conté un RPM per al TaskServer (taskd), així que l'hem de crear des del codi font en un paquet RPM nosaltres mateixos.

1. Instal·leu GCC, Make, RPM Build, desenvolupament i eines de signatura.

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

2. Creeu un directori GnuPG que contindrà els fitxers GPG necessaris per signar el nostre RPM.

   mkdir .gnupg
   

3. Quan es crea una clau, necessitem entropia del sistema per aleatoritzar-la correctament. El rngddimoni genera l'entropia necessària a partir de /dev/urandom. Així que instal·lem-ho ara.

   yum install rngd -y
   

4. Inicieu el rngddimoni per generar entropia. L' opció -r apunta a /dev/urandomen lloc de la predeterminada /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generar una clau. L' opció --gen-key diu a gpg que generi un nou parell de claus.

   gpg --gen-key
   

6. Per a l'opció " Si us plau, seleccioneu quin tipus de clau voleu: ", seleccioneu " (1) RSA i RSA (per defecte) " per al tipus de clau introduint 1 i prement la tecla Retorn/Enter .

7. Per a l'opció " Quina mida de tecla voleu? (2048) ", seleccioneu la predeterminada prement la tecla Retorn/Enter .

8. Per a l'opció " Especifiqueu quant de temps ha de ser vàlida la clau. ", seleccioneu la predeterminada prement la tecla Retorn/Enter .

9. Per a l'opció " És correcte? (y/N) ", introduïu y i premeu la tecla Retorn/Enter .

10. A " Nom real: ", introduïu el nom que trieu i premeu la tecla Retorn/Enter .

11. A " Adreça de correu electrònic: ", introduïu l'adreça de correu electrònic que trieu i premeu la tecla Retorn/Enter .

12. La secció Comentari: es pot deixar en blanc si així ho trieu.

13. Feu els canvis necessaris si no heu introduït la vostra informació correctament. Si esteu satisfet amb la informació d' ID d'USUARI que es mostra, introduïu O (lletra majúscula O, no zero) i premeu la tecla Retorn/Enter .

14. Ara GnuPG us demanarà que creeu i verifiqueu una contrasenya per al vostre parell de claus.

15. Un cop hàgiu introduït les vostres contrasenyes, el vostre parell de claus GnuPG es crearà al .gnupgdirectori del vostre directori d'usuaris.

16. Executeu aquesta ordre per mostrar el contingut del .gnupgdirectori. Ha de contenir el següent directori private-keys-v1.di els arxius pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exporteu el parell de claus creat. L' opció --export indica a GnuPG que exporti el parell de claus. L' opció -a indica a GnuPG que produeixi el parell de claus en format d'armadura ascii . Substituïu " Joe Q. Public " pel nom que heu introduït en crear el parell de claus al pas 10 anterior. Substituïu " jqpublic " amb el text que trieu.

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

18. Importeu el parell de claus al magatzem de claus RPM. Substituïu el " jqpublic " pel text que heu escollit al pas #17.

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

19. Verifiqueu que el parell de claus s'ha afegit al magatzem de claus RPM. L'opció --q gpg-pubkey consulta el magatzem de claus RPM GnuPG. El %{name}-%{versió}-%{release} --> %{summary}\n mostra el resultat en un format llegible per l'home.

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

20. En crear un .rpmmacros file, es pot personalitzar RPM per dur a terme els comportaments assignats (exemple: facilitar la signatura automàtica d'RPM). Utilitzeu el nanoprograma per crear el fitxer.

    nano .rpmmacros
    

21. A continuació, afegiu el text següent al .rpmmacrosfitxer.

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

22. Deseu el document introduint les combinacions de teclat següents. Els CTRL + X Claus. A continuació, la clau S. Finalment, la clau Retorn/Enter .

23. Aquesta comanda a continuació configurarà el vostre entorn de compilació RPM. Això afegirà macros addicionals al .rpmmacrosfitxer que heu creat al pas #20 i crearà els directoris necessaris per crear i emmagatzemar RPM.

    rpmdev-setuptree
    

24. Executeu aquesta ordre per mostrar el contingut del directori rpmbuild. Hauria de contenir els següents directoris SOURCES , RPMS , BUILD , SRPMS i SPECS .

    find rpmbuild
    

25. Baixeu el codi font del TaskServer (taskd) al rpmbuild/SOURCESdirectori.

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

26. Mata el rgndprocés en execució .

    sudo kill -9 rngd
    

Pas 3: creeu TaskServer (taskd) RPM des de la font

1. Per crear un nou RPM des de la font, s'ha de crear un fitxer SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Afegiu el text següent al taskd.specfitxer.

   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. Elimina els privilegis de root i realitza la resta de les teves ordres com a usuari habitual.

   exit
   

   TaskServer (taskd) ja està configurat i llest perquè els clients TaskWarrior (task) es connectin.

Pas 6: creeu el vostre primer grup i usuari de TaskWarrior

1. Per crear, suprimir, modificar i sincronitzar les vostres tasques, necessitareu un compte d'usuari. Tanmateix, abans de poder afegir usuaris, primer haureu de crear un grup organitzatiu. Executeu l'ordre següent per crear el vostre primer grup. Substitueix GRUP per un nom fàcilment reconeixible.

2. IMPORTANT! L' taskdordre per crear grups/usuaris s'ha d'executar com a taskdusuari. Si s'executa com a usuari root, es crearan directoris i fitxers propietat de l'usuari root amb els /var/lib/taskd/orgsquals evitarà que els clients TaskWarrior (tasques) puguin accedir o modificar qualsevol cosa del grup al qual han estat assignats. Es denegarà l'accés.

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

3. Ara, que heu creat el vostre primer grup, creem el vostre primer usuari. Executeu l'ordre següent per crear un usuari assignat al grup creat al pas #1. Copieu i enganxeu la clau d'usuari, l'usuari i el grup generats en un fitxer de text. Repetiu el procés per afegir usuaris addicionals.

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

Pas 7: instal·leu els clients TaskWarrior

Windows 10 (creació posterior a 1607+)

Per utilitzar TaskWarrior (tasca) a Windows 10, heu d'instal·lar el subsistema de Windows per a Linux des de la botiga de Windows.

1. Per instal·lar WSL, cal un indicador de Powershell elevat. Premeu la tecla de la finestra i escriviu powershell . Feu clic amb el botó dret a Windows Powershell a la part superior dels resultats i seleccioneu " Executar com a administrador ". A l'indicador Control del compte d'usuari, feu clic a Sí . Copieu i enganxeu el text que trobareu a continuació a les finestres de Powershell. Quan WSL s'acabi d'instal·lar, premeu la tecla Y per reiniciar Windows.

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

2. Després de reiniciar, obriu un indicador d'ordres i escriviu l'ordre següent bash . Això instal·larà Ubuntu a Windows. Premeu la tecla I . Ara es descarregarà i s'extreurà. Trieu un nom d'usuari i una contrasenya.

   bash
   

3. Ara és el moment d'instal·lar TaskWarrior (tasca). Escriviu la següent comanda dins de la consola.

   sudo apt-get install task -y
   

4. Escriviu exit dues vegades per sortir del terminal bash i l'indicador d'ordres de Windows.

5. Feu clic al botó del menú Inici. Escriviu ubuntu . Feu clic amb el botó dret a Bash a Ubuntu a Windows . Seleccioneu Fixa a la barra de tasques . Això proporciona comoditat per accedir ràpidament a bash per accedir a TaskWarrior (tasca).

6. Feu clic a la icona d'Ubuntu que acabeu de crear a la barra de tasques. Això obrirà una finestra de terminal que executa Bash. Escriviu l'ordre següent a continuació per crear el directori de dades de TaskWarrior (tasques) ( ~/.task/) i el fitxer de configuració ( .taskrc).

   task version
   yes
   

7. Heu de moure el certificates.zipfitxer que heu desat anteriorment durant la configuració del TaskServer al ~/.taskd/directori dins del vostre directori d'usuari. Per extreure els fitxers del fitxer zip, unzipprimer instal·leu el programa. Copieu i enganxeu les ordres següents a continuació substituint la ubicació real de la vostra còpia de certificates.zip.

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

8. Escriviu les ordres següents per configurar TaskWarrior (task) per connectar amb TaskServer (taskd). Substitueix NOM pel nom amb el que has anomenat el teu certificat i clau, GRUP pel grup que has creat, Joe Q. Públic amb el nom d'usuari que has creat i XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX amb la clau assignada quan el teu usuari es va crear al servidor 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. Ara és el moment de sincronitzar TaskWarrior (task) amb TaskServer (taskd). Executeu l'ordre següent per inicialitzar la base de dades.

   task sync init
   

   La sincronització entre el vostre client TaskWarrior (task) i el TaskServer (taskd) ja està configurada a la plataforma Windows 10.

Android

Per utilitzar TaskWarrior (tasca) a Android, cal que instal·leu TaskWarrior per a Android des de Google Play Store.

1. Instal·leu l'aplicació TaskWarrior (task) per a Android a la Play Store de Google.

2. Obriu l'aplicació TaskWarrior (task) per a Android.

3. L'aplicació us demanarà que creeu un compte amb el nom del compte desitjat . Introduïu el nom que vau triar quan vau crear un nom d'usuari per a un usuari de TaskServer (taskd).

4. Deixeu la carpeta de dades a la configuració predeterminada de <<Crea nou>> i toqueu el botó D' acord . Utilitzeu una aplicació de gestor de fitxers per crear una carpeta a l'arrel d'emmagatzematge (per exemple: /storage/emulate/0/Certs). Envia l'aplicació en segon pla.

5. Copieu el certificates.zipfitxer que heu creat anteriorment i extreu-ne el contingut al directori creat al pas 4.

6. Primer pla l'aplicació "TaskWarrior (tasca) per a Android" i toqueu el menú a l'extrem superior esquerre de l'aplicació per obrir-la.

7. Desplaceu-vos cap avall fins a la part inferior del menú i toqueu l' opció Configuració .

8. Això obrirà un senzill editor de text de l'aplicació TaskWarrior per a Android integrat.

9. Introduïu les opcions següents per configurar la sincronització amb el vostre TaskServer (taskd). Reemplaçar els taskd.ca/ taskd.certificateles variables / taskd.key` amb la ca / certificat / clau trajectòria real de directori (s), NOM , amb el que vostè va designar al seu certificat i la clau, GRUP amb el grup que ha creat, Joe Q. públic amb el nom d'usuari que ha creat i XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXX amb la clau assignada quan vau crear l'usuari al servidor 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. Toqueu la icona del disquet per desar la configuració.

La sincronització entre el vostre client TaskWarrior (task) i el TaskServer (taskd) ja està configurada a la plataforma Android.

Linux

1. Consulteu la secció de distribució de TaskWarrior (tasques) per instal·lar-lo per a la vostra distribució Linux particular .

2. Obre una finestra de terminal. Escriviu l'ordre següent a continuació per crear el directori de dades de TaskWarrior (tasques) ( ~/.task/) i el fitxer de configuració ( .taskrc).

   task version
   yes
   

3. Heu de moure el certificates.zipfitxer que heu desat anteriorment a la configuració del TaskServer al ~/.taskd/directori dins del vostre directori d'usuari. Per extreure els fitxers del fitxer zip, instal·leu unzipprimer el programa per a la vostra distribució particular. Copieu i enganxeu les ordres següents a continuació, substituint la ubicació real de la vostra còpia de certificates.zip.

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

4. Escriviu les ordres següents per configurar TaskWarrior (task) per connectar amb TaskServer (taskd). Substitueix NOM pel nom amb el que has anomenat el teu certificat i clau, GRUP pel grup que has creat, Joe Q. Públic amb el nom d'usuari que has creat i XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX amb la clau assignada quan el teu usuari es va crear al servidor 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. Ara és el moment de sincronitzar TaskWarrior (task) amb TaskServer (taskd). Executeu l'ordre següent per inicialitzar la base de dades.

   task sync init
   

Addendum: si executeu Gnome Shell, hi ha una extensió anomenada TaskWhisper que s'integra amb TaskWarrior (tasca).

La sincronització entre el vostre client TaskWarrior (task) i el TaskServer (taskd) ja està configurada a la vostra distribució de Linux preferida.