Installer TaskServer (taskd) på CentOS 7

TaskWarrior er et open source-tidsstyringsværktøj, der er en forbedring af Todo.txt-applikationen og dens kloner. På grund af det faktum, at den gennemsnitlige person bruger flere enheder/platforme i deres daglige tidsplan, er det afgørende at have muligheden for at have et centraliseret lager, hvor dataene kan tilgås og opdateres fra enhver enhed. Denne vejledning vil fokusere på opsætning af både serveren, kaldet TaskServer (taskd), og klienten, kaldet TaskWarrior (opgave), hvilket giver flere klientenheder mulighed for at få adgang til og udveksle data sikkert.

Den har følgende funktioner:

• Ubegrænsede opgaver
• Opgaveprioritering
• Søgefiltrering
• Tagging
• Automatisk synkronisering
• Automatisk backup
• Fuld kontrol og privatliv
• Krypteret kommunikation

Forudsætninger

• En CentOS 7 x64-serverinstans.
• En sudo- bruger.
• Domænenavn pegede på en Vultr-instans ( taskd.example.com )

Trin 1: Opdater systemet

Log ind som din sudo-bruger for at installere EPEL Repository og opdatere systemet som følger:

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

Trin 2: Installer RPM Build og værktøjer til bygning

EPEL-lageret indeholder ikke en RPM til TaskServeren (taskd), så vi skal selv bygge det fra kilden til en RPM-pakke.

1. Installer GCC, Make, RPM Build, udvikling og signeringsværktøjer.

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

2. Opret en GnuPG-mappe, som vil indeholde de GPG-filer, der er nødvendige for at signere vores RPM.

   mkdir .gnupg
   

3. Når vi opretter en nøgle, kræver vi entropi i systemet for at randomisere den korrekt. Den rngddæmonen genererer entropien nødvendig fra /dev/urandom. Så lad os installere det nu.

   yum install rngd -y
   

4. Start rngddæmonen for at generere entropi. Indstillingen -r peger på i /dev/urandomstedet for standarden /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generer en nøgle. Den --gen-key løsning fortæller gpg at generere nyt nøglepar.

   gpg --gen-key
   

6. For " Vælg venligst hvilken type nøgle du ønsker: " valgmulighed, vælg " (1) RSA og RSA (standard) " for nøgletypen ved at indtaste 1 og trykke på Retur/Enter- tasten.

7. For indstillingen " Hvilken nøglestørrelse vil du have? (2048) " skal du vælge standarden ved at trykke på Retur/Enter- tasten.

8. For " Angiv venligst, hvor længe nøglen skal være gyldig. ", skal du vælge standard ved at trykke på Retur/Enter- tasten.

9. Indtast y for " Er dette korrekt? (y/N) ", og tryk på Retur/Enter- tasten.

10. Indtast et navn efter eget valg under " Rigtigt navn: ", og tryk på Retur/Enter- tasten.

11. Under " E-mailadresse: " skal du indtaste en e-mail-adresse efter eget valg og trykke på Retur/Enter- tasten.

12. Den Kommentar: sektion kan stå tomt, hvis du ønsker det.

13. Foretag de nødvendige ændringer, hvis du ikke har indtastet dine oplysninger korrekt. Hvis du er tilfreds med de viste USER-ID- oplysninger, skal du indtaste O (stort bogstav O, ikke nul) og trykke på Retur/Enter- tasten.

14. GnuPG vil nu bede dig om at oprette og bekræfte en adgangskode til dit nøglepar.

15. Efter du har indtastet dine adgangskoder, vil dit GnuPG-nøglepar blive oprettet under .gnupgbiblioteket i dit brugerbibliotek.

16. Kør denne kommando for at vise indholdet af .gnupgmappen. Den skal indeholde følgende mappe private-keys-v1.dog filer pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Eksporter det oprettede nøglepar. Indstillingen --export instruerer GnuPG om at eksportere nøgleparret. Den -a valgmulighed instruerer GnuPG til at lave den nøglepar i ASCII rustning format . Erstat " Joe Q. Public " med det navn, du har indtastet, da du oprettede nøgleparret i trin #10 ovenfor. Erstat " jqpublic " med den tekst du vælger.

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

18. Importer nøgleparret til RPM-nøglelageret. Erstat " jqpublic " med den tekst, du valgte i trin #17.

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

19. Bekræft, at nøgleparret blev tilføjet til RPM-nøglelageret. Indstillingen --q gpg-pubkey forespørger RPM GnuPG nøglelageret. Den % {name} -% {udgave} -% {release} ->% {resumé} \ n viser resultatet i et menneskeligt læsbart format.

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

20. Ved at oprette en .rpmmacros file, kan RPM tilpasses til at udføre tildelt adfærd (eksempel: nem automatisk signering af RPM'er). Brug nanoprogrammet til at oprette filen.

    nano .rpmmacros
    

21. Tilføj derefter følgende tekst nedenfor i .rpmmacrosfilen.

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

22. Gem dokumentet ved at indtaste følgende tastaturkombinationer. De CTRL + X nøgler. Derefter S- tasten. Til sidst, Retur/Enter- tasten.

23. Denne kommando nedenfor opsætter dit RPM-byggemiljø. Dette vil tilføje yderligere makroer til den .rpmmacrosfil, du har oprettet i trin #20, og oprette de nødvendige mapper til at bygge og gemme RPM'er.

    rpmdev-setuptree
    

24. Kør denne kommando for at vise indholdet af rpmbuild-mappen. Den skal indeholde følgende vejvisere KILDER , RPMS , BUILD , SRPMS og SPECS .

    find rpmbuild
    

25. Download TaskServer (taskd) kildekoden til rpmbuild/SOURCESbiblioteket.

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

26. Dræb den kørende rgndproces.

    sudo kill -9 rngd
    

Trin 3: Byg TaskServer (taskd) RPM fra kilden

1. For at kunne bygge en ny RPM fra kilden, skal der oprettes en TaskServer (taskd) SPEC-fil.

   nano rpmbuild/SPECS/taskd.spec
   

2. Tilføj følgende tekst nedenfor i taskd.specfilen.

   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 <jarrett+rpmbuild@jarrettgraham.com> - 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-privilegier og udfør resten af ​​dine kommandoer som din almindelige bruger.

   exit
   

   TaskServer (taskd) er nu sat op og klar til, at TaskWarrior (opgave) klienter kan oprette forbindelse.

Trin 6: Opret din første TaskWarrior-gruppe og bruger

1. For at oprette, slette, ændre og synkronisere dine opgaver skal du bruge en brugerkonto. Men før du kan tilføje brugere, skal du først oprette en organisationsgruppe. Kør kommandoen nedenfor for at oprette din første gruppe. Erstat GROUP med et letgenkendeligt navn.

2. VIGTIG! Den taskdkommando til at oprette grupper / brugere skal være løb som taskdbruger. Kører du som root-bruger, oprettes mapper og filer, der ejes af root-brugeren, /var/lib/taskd/orgshvilket forhindrer TaskWarrior (opgave)-klienter i at få adgang til eller ændre noget i den gruppe, som de er blevet tildelt. Adgang vil blive nægtet.

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

3. Nu, hvor du har oprettet din første gruppe, lad os oprette din første bruger. Kør kommandoen nedenfor for at oprette en bruger, der er tildelt den gruppe, der blev oprettet i trin #1. Kopier og indsæt den genererede brugernøgle, bruger og gruppe i en tekstfil. Gentag processen for at tilføje flere brugere.

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

Trin 7: Installer TaskWarrior-klienter

Windows 10 (byg senere end 1607+)

For at bruge TaskWarrior (opgave) på Windows 10 skal du installere Windows-undersystemet til Linux fra Windows Store.

1. For at installere WSL kræves en forhøjet Powershell-prompt. Tryk på Window-tasten og skriv powershell . Højreklik på Windows Powershell øverst i resultaterne og vælg " Kør som administrator ". Klik på Ja ved prompten Brugerkontokontrol . Kopier og indsæt teksten nedenfor i Powershell-vinduerne. Når WSL er færdig med installationen, skal du trykke på Y-tasten for at genstarte Windows.

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

2. Efter genstart skal du åbne en kommandoprompt og skrive følgende kommando bash . Dette vil installere Ubuntu på Windows. Tryk på Y-tasten . Det vil nu blive downloadet og udtrukket. Vælg et brugernavn og en adgangskode.

   bash
   

3. Nu er det tid til at installere TaskWarrior (opgave). Skriv følgende kommando inde i konsollen.

   sudo apt-get install task -y
   

4. Skriv exit to gange for at afslutte bash-terminalen og Windows-kommandoprompten.

5. Klik på knappen Startmenu. Skriv ubuntu . Højreklik på Bash på Ubuntu på Windows . Vælg Fastgør til proceslinjen . Dette giver bekvemmelighed for hurtigt at få adgang til bash for at få adgang til TaskWarrior (opgave).

6. Klik på det Ubuntu-ikon, du lige har oprettet, på proceslinjen. Dette åbner et terminalvindue, der kører Bash. Indtast følgende kommando nedenfor for at oprette TaskWarrior (opgave) datamappe ( ~/.task/) og konfigurationsfil ( .taskrc).

   task version
   yes
   

7. Du skal flytte den certificates.zipfil, du har gemt tidligere under TaskServer-opsætningen, til ~/.taskd/mappen inde i dit brugerbibliotek. For at udpakke filerne fra zip-filen skal du først installere unzipprogrammet. Kopiér og indsæt følgende kommandoer nedenfor og erstatter den faktiske placering af din kopi af certificates.zip.

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

8. Indtast følgende kommandoer for at indstille TaskWarrior (opgave) til at oprette forbindelse til TaskServer (taskd). Erstat NAME med det, du har navngivet dit certifikat og din nøgle, GROUP med den gruppe, du har oprettet, Joe Q. Public med det brugernavn, du har oprettet, og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX med den nøgle, som din bruger tildelte blev oprettet på TaskWarrior (taskd) serveren.

   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. Nu er det tid til at synkronisere TaskWarrior (opgave) med TaskServer (taskd). Kør kommandoen nedenfor for at initialisere databasen.

   task sync init
   

   Synkronisering mellem din TaskWarrior (opgave) klient og TaskServer (taskd) er nu konfigureret på Windows 10 platformen.

Android

For at bruge TaskWarrior (opgave) på Android skal du installere TaskWarrior til Android fra Google Play Butik.

1. Installer TaskWarrior (opgave) til Android-appen i Googles Play Butik.

2. Åbn TaskWarrior (opgave) til Android-appen.

3. Du vil blive bedt af appen om at oprette en konto med et ønsket kontonavn . Indtast det navn, du valgte, da du oprettede et brugernavn til en TaskServer-bruger (taskd).

4. Forlad datamappen til standardindstillingen <<Opret ny>> og tryk på OK- knappen. Brug en filhåndteringsapp til at oprette en mappe i din lagerrod (for eksempel: /storage/emulate/0/Certs). Send appen til baggrunden.

5. Kopier den certificates.zipfil, du har oprettet tidligere, og udpak dens indhold i din mappe oprettet i trin #4.

6. Forgrund appen "TaskWarrior (opgave) For Android", og tryk på menuen i øverste venstre hjørne af appen for at åbne den.

7. Rul ned til bunden af ​​menuen, og tryk på indstillingen Indstillinger.

8. Dette åbner en simpel indbygget TaskWarrior For Android-app-teksteditor.

9. Indtast følgende muligheder for at konfigurere synkronisering med din TaskServer (taskd). Erstat variablerne taskd.ca/ taskd.certificate/taskd.key` med den/de faktiske ca/certifikat/nøgle-mappesti(r), NAME med det, du navngav dit certifikat og din nøgle, GROUP med den gruppe, du oprettede, Joe Q. Public med det brugernavn, du oprettede og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX med den nøgle, der blev tildelt, da du oprettede din bruger på TaskWarrior-serveren (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. Tryk på disketteikonet for at gemme dine indstillinger.

Synkronisering mellem din TaskWarrior (opgave)-klient og TaskServeren (taskd) er nu opsat på Android-platformen.

Linux

1. Se TaskWarrior (opgave) distributionssektionen for at installere til din specifikke Linux-distribution .

2. Åbn et terminalvindue. Indtast følgende kommando nedenfor for at oprette TaskWarrior (opgave) datamappe ( ~/.task/) og konfigurationsfil ( .taskrc).

   task version
   yes
   

3. Du skal flytte den certificates.zipfil, du tidligere har gemt i TaskServer-opsætningen, til ~/.taskd/mappen inde i dit brugerbibliotek. For at udpakke filerne fra zip-filen skal du først installere unzipprogrammet til din særlige distribution. Kopiér og indsæt følgende kommandoer nedenfor, og erstatte den faktiske placering af din kopi af certificates.zip.

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

4. Indtast følgende kommandoer for at indstille TaskWarrior (opgave) til at oprette forbindelse til TaskServer (taskd). Erstat NAME med det, du har navngivet dit certifikat og din nøgle, GROUP med den gruppe, du har oprettet, Joe Q. Public med det brugernavn, du har oprettet, og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX med den nøgle, som din bruger tildelte blev oprettet på TaskWarrior (taskd) serveren.

   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. Nu er det tid til at synkronisere TaskWarrior (opgave) med TaskServer (taskd). Kør kommandoen nedenfor for at initialisere databasen.

   task sync init
   

Tillæg: Hvis du kører Gnome Shell, er der en udvidelse kaldet TaskWhisper, der integreres med TaskWarrior (opgave).

Synkronisering mellem din TaskWarrior (opgave)-klient og TaskServer (taskd) er nu opsat på din foretrukne Linux-distro.