Installige TaskServer (taskd) operatsioonisüsteemi CentOS 7

TaskWarrior on avatud lähtekoodiga ajahaldustööriist, mis täiustab rakendust Todo.txt ja selle kloone. Kuna keskmine inimene kasutab oma igapäevases ajakavas mitut seadet/platvormi, on ülioluline võimalus omada tsentraliseeritud hoidlat, kus andmetele pääseb juurde ja neid saab värskendada mis tahes seadmest. See õpetus keskendub nii serveri nimega TaskServer (taskd) kui ka kliendi, nimega TaskWarrior (ülesanne) seadistamisele, võimaldades mitmel kliendiseadmel turvaliselt andmetele juurde pääseda ja neid vahetada.

Sellel on järgmised omadused:

• Piiramatult ülesandeid
• Ülesannete prioritiseerimine
• Otsingu filtreerimine
• Sildistamine
• Automaatne sünkroonimine
• Automaatne varundamine
• Täielik kontroll ja privaatsus
• Krüpteeritud suhtlus

Eeltingimused

• CentOS 7 x64 serveri eksemplar.
• Sudo kasutaja.
• Domeeninimi viitas Vultri eksemplarile ( taskd.example.com )

1. samm: värskendage süsteemi

Logige sisse oma sudo kasutajana, et installida EPEL Repository ja värskendada süsteemi järgmiselt:

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

2. samm: installige RPM Build ja ehitustööriistad

EPEL-i hoidla ei sisalda TaskServeri (taskd) RPM-i, seega peame selle allikast ise RPM-paketiks ehitama.

1. Installige GCC, Make, RPM Build, arendus- ja allkirjastamistööriistad.

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

2. Looge GnuPG kataloog, mis sisaldab meie RPM-i allkirjastamiseks vajalikke GPG-faile.

   mkdir .gnupg
   

3. Võtme loomisel vajame süsteemis entroopiat, et seda õigesti randomiseerida. rngdDeemon tekitab entroopia vajalikud alates /dev/urandom. Nii et installime selle kohe.

   yum install rngd -y
   

4. rngdEntroopia genereerimiseks käivitage deemon. Valik -r osutab /dev/urandomvaikeväärtuse asemel /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Looge võti. Valik --gen-key käsib gpg-l luua uue võtmepaari.

   gpg --gen-key
   

6. Valiku " Palun valige, millist võtit soovite: " jaoks valige võtme tüübiks " (1) RSA ja RSA (vaikimisi) ", sisestades 1 ja vajutades klahvi Return/Enter .

7. Valiku " Millist klahvisuurust soovite? (2048) " jaoks valige vaikeseade, vajutades klahvi Return/Enter .

8. Valiku " Palun täpsustage, kui kaua võti peaks kehtima " jaoks valige vaikeväärtus, vajutades klahvi Return/Enter .

9. Valiku " Kas see on õige? (y/N) " jaoks sisestage y ja vajutage klahvi Return/Enter .

10. Vastavalt " Tegelik nimi: " Sisestage nimi Teie valitud ja vajutage Tagasi / Sisesta võti.

11. Vastavalt " E-posti aadress: ", sisestage e-posti aadress Teie valitud ja vajutage Tagasi / Sisesta võti.

12. Kommentaar: sektsioonis saab tühjaks, kui sa nii valida.

13. Kui te ei sisestanud oma andmeid õigesti, tehke vajalikud muudatused. Kui olete rahul user-id teave kuvatakse, sisestage O (suurtäht O, mitte null) ja vajutage Tagasi / Sisesta võti.

14. GnuPG palub teil nüüd oma võtmepaari jaoks parool luua ja kinnitada.

15. Pärast paroolide sisestamist luuakse teie GnuPG võtmepaar .gnupgteie kasutajakataloogi kataloogi alla.

16. Käivitage see käsk, et kuvada .gnupgkataloogi sisu . See peaks sisaldama järgmist kataloogi private-keys-v1.dja faile pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Ekspordi loodud võtmepaar. --Export võimalus juhendab GnuPG eksportida võtmepaari. Valik -a juhendab GnuPG-d väljastama võtmepaari ascii armor formaadis . Asendage " Joe Q. Public " nimega, mille sisestasite ülaltoodud sammus #10 võtmepaari loomisel. Asendage " jqpublic " mis tahes valitud tekstiga.

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

18. Importige võtmepaar RPM-i võtmesalve. Asendage " jqpublic " tekstiga, mille valisite sammus nr 17.

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

19. Veenduge, et võtmepaar lisati RPM-i võtmesalve. Q- gpg-avaliku võtme võimalus päringu RPM GnuPG võtmesalvestuse. % {Name} -% {versiooni} -% {vabastamist} ->% {kokkuvõte} \ n kuvab tulemuse inimese loetavas vormingus.

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

20. Luues .rpmmacros file, saab RPM-i kohandada nii, et see täidaks määratud käitumist (näide: RPM-ide automaatse allkirjastamise hõlbustamine). Kasutage nanofaili loomiseks programmi.

    nano .rpmmacros
    

21. Seejärel lisage .rpmmacrosfaili järgmine tekst .

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

22. Salvestage dokument, sisestades järgmised klahvikombinatsioonid. CTRL + X Keys. Seejärel S- klahv. Lõpuks tagastus-/sisestusklahv .

23. See allolev käsk seadistab teie RPM-i ehituskeskkonna. See lisab .rpmmacrossammus #20 loodud failile täiendavad makrod ja loob vajalikud kataloogid RPM-ide loomiseks ja salvestamiseks.

    rpmdev-setuptree
    

24. Käivitage see käsk, et kuvada rpmbuildi kataloogi sisu. See peaks sisaldama järgmisi katalooge SOURCES , RPMS , BUILD , SRPMS ja SPECS .

    find rpmbuild
    

25. Laadige rpmbuild/SOURCESkataloogi alla TaskServeri (taskd) lähtekood .

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

26. Tapa jooksev rgndprotsess.

    sudo kill -9 rngd
    

3. samm: looge TaskServer (taskd) RPM allikast

1. Lähtest uue RPM-i loomiseks tuleb luua TaskServeri (taskd) SPEC-fail.

   nano rpmbuild/SPECS/taskd.spec
   

2. Lisage taskd.specfaili järgmine tekst .

   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. TÄHTIS! taskdKäsu luua rühmad / kasutajad peavad olema jooksis nagu taskdkasutaja. Juurkasutajana /var/lib/taskd/orgstöötamine loob juurkasutajale kuuluvad kataloogid ja failid, mis takistavad TaskWarriori (ülesannete) klientidel juurdepääsu või muutmise millelegi rühmas, kuhu nad on määratud. Juurdepääs keelatakse.

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

3. Nüüd, kui olete loonud oma esimese grupi, loome teie esimese kasutaja. Käivitage allolev käsk, et luua kasutaja, kes on määratud sammus #1 loodud rühma. Kopeerige ja kleepige loodud kasutajavõti, kasutaja ja rühm tekstifaili. Täiendavate kasutajate lisamiseks korrake seda protsessi.

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

7. samm: installige TaskWarriori kliendid

Windows 10 (hilisem kui 1607+)

TaskWarriori (ülesanne) kasutamiseks opsüsteemis Windows 10 peate Windowsi poest installima Windowsi alamsüsteemi Linuxi jaoks .

1. WSL-i installimiseks on vaja kõrgendatud Powershelli viipa. Vajutage Window Key ja tüüp powershell . Paremklõpsake tulemuste ülaosas Windows Powershelli ja valige käsk " Käivita administraatorina ". Klõpsake kasutajakonto kontrolli viibal Jah . Kopeerige ja kleepige Powershelli akendesse alltoodud tekst. Kui WSL on installimise lõpetanud, vajutage Windowsi taaskäivitamiseks klahvi Y.

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

2. Pärast taaskäivitamist avage käsuviip ja tippige järgmine käsk bash . See installib Ubuntu Windowsi. Vajutage Y Key . Nüüd laaditakse see alla ja ekstraheeritakse. Valige kasutajanimi ja parool.

   bash
   

3. Nüüd on aeg installida TaskWarrior (ülesanne). Tippige konsooli sisse järgmine käsk.

   sudo apt-get install task -y
   

4. Liik väljumise kaks korda väljuda bash terminali ja Windows käsureale.

5. Klõpsake nuppu Start Menüü. Tippige ubuntu . Paremklõpsake Windowsi Ubuntus Bash . Valige Kinnita tegumiribale . See pakub mugavust kiireks juurdepääsuks bashile, et pääseda juurde TaskWarriorile (ülesanne).

6. Klõpsake tegumiribal äsja loodud Ubuntu ikooni. See avab terminali akna, kus töötab Bash. TaskWarriori (ülesande) andmekataloogi ( ~/.task/) ja konfiguratsioonifaili ( .taskrc) loomiseks tippige allpool järgmine käsk .

   task version
   yes
   

7. Peate teisaldama certificates.zipfaili, mille olete varem TaskServeri seadistamise ajal salvestanud ~/.taskd/, oma kasutajakataloogi sees olevasse kataloogi. Failide zip-failist ekstraktimiseks installige esmalt unzipprogramm. Kopeerige ja kleepige järgmised käsud, mis asendavad oma koopia tegeliku asukoha certificates.zip.

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

8. Tippige järgmised käsud, et seadistada TaskWarrior (task) TaskServeriga (taskd) ühenduse loomiseks. Asendage NAME selle nimega, mille olete oma sertifikaadile ja võtmele pannud , GROUP teie loodud grupiga, Joe Q. Avalik teie loodud kasutajanimega ja XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX võtmega, mille teie kasutaja määras. loodi TaskWarrior (taskd) serveris.

   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. Nüüd on aeg TaskWarrior (ülesanne) TaskServeriga (taskd) sünkroonida. Andmebaasi lähtestamiseks käivitage allolev käsk.

   task sync init
   

   TaskWarrior (task) kliendi ja TaskServeri (taskd) sünkroonimine on nüüd Windows 10 platvormil seadistatud.

Android

TaskWarriori (ülesanne) kasutamiseks Androidis peate installima TaskWarrior For Android Google Play poest.

1. Installige Google Play poest Androidi rakendus TaskWarrior (task).

2. Avage Androidi rakendus TaskWarrior (task).

3. Rakendus palub teil luua soovitud kontonimega konto . Sisestage nimi, mille valisite TaskServeri (taskd) kasutaja kasutajanime loomisel.

4. Jätke andmekaust vaikeseadele <<Loo uus>> ja puudutage nuppu OK . Kasutage failihalduri rakendust, et luua oma salvestusjuures kaust (näiteks: /storage/emulate/0/Certs). Saatke rakendus taustale.

5. Kopeerige certificates.zipvarem loodud fail ja ekstraheerige selle sisu 4. etapis loodud kataloogist.

6. Esiplaanil rakendus „TaskWarrior (task) For Android” ja puudutage rakenduse avamiseks vasakus ülanurgas olevat menüüd.

7. Kerige alla menüü allossa ja puudutage valikut Seaded .

8. See avab lihtsa sisseehitatud TaskWarrior Androidi rakenduse tekstiredaktori.

9. Sisestage oma TaskServeriga (taskd) sünkroonimise seadistamiseks järgmised valikud. Asendage muutujad taskd.ca/ taskd.certificate/taskd.key` tegeliku ca/certificate/key kataloogi tee(de)ga, NAME sertifikaadile ja võtmele antud nimega, GROUP enda loodud rühmaga, Joe Q. Avalik teie loodud kasutajanimega ja XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX võtmega, mis määrati kasutaja loomisel TaskWarrior (taskd) serveris.

   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. Seadete salvestamiseks puudutage disketiikooni.

Sünkroonimine TaskWarriori (task) kliendi ja TaskServeri (taskd) vahel on nüüd Android-platvormil seadistatud.

Linux

1. Oma konkreetse Linuxi distributsiooni jaoks installimiseks vaadake jaotist TaskWarrior (ülesanne) jaotamine .

2. Avage terminali aken. TaskWarriori (ülesande) andmekataloogi ( ~/.task/) ja konfiguratsioonifaili ( .taskrc) loomiseks tippige allpool järgmine käsk .

   task version
   yes
   

3. Peate teisaldama certificates.zipfaili, mille olete varem TaskServeri seadistuses salvestanud ~/.taskd/, oma kasutajakataloogis olevasse kataloogi. Failide zip-failist ekstraktimiseks installige esmalt unzipprogramm oma konkreetse distributsiooni jaoks. Kopeerige ja kleepige järgmised käsud, asendades oma koopia tegeliku asukoha certificates.zip.

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

4. Tippige järgmised käsud, et seadistada TaskWarrior (task) TaskServeriga (taskd) ühenduse loomiseks. Asendage NAME selle nimega, mille olete oma sertifikaadile ja võtmele pannud , GROUP teie loodud grupiga, Joe Q. Avalik teie loodud kasutajanimega ja XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX võtmega, mille teie kasutaja määras. loodi TaskWarrior (taskd) serveris.

   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. Nüüd on aeg TaskWarrior (ülesanne) TaskServeriga (taskd) sünkroonida. Andmebaasi lähtestamiseks käivitage allolev käsk.

   task sync init
   

Lisa: kui kasutate Gnome Shelli, on laiendus nimega TaskWhisper, mis integreerub TaskWarrioriga (ülesanne).

Sünkroonimine TaskWarriori (task) kliendi ja TaskServeri (taskd) vahel on nüüd seadistatud teie lemmik Linuxi distros.