Installer TaskServer (taskd) på CentOS 7

TaskWarrior er et åpen kildekode-tidsstyringsverktøy som er en forbedring av Todo.txt-applikasjonen og dens kloner. På grunn av det faktum at den gjennomsnittlige personen bruker flere enheter/plattformer i sin daglige timeplan, er det avgjørende å ha muligheten til å ha et sentralisert arkiv hvor dataene kan nås og oppdateres fra hvilken som helst enhet. Denne opplæringen vil fokusere på å sette opp både serveren, kalt TaskServer (taskd), og klienten, kalt TaskWarrior (oppgave), slik at flere klientenheter kan få tilgang til og utveksle data på en sikker måte.

Den har følgende funksjoner:

• Ubegrensede oppgaver
• Oppgaveprioritering
• Søkefiltrering
• Tagging
• Automatisk synkronisering
• Automatisk sikkerhetskopiering
• Full kontroll og personvern
• Kryptert kommunikasjon

Forutsetninger

• En CentOS 7 x64-serverforekomst.
• En sudo- bruker.
• Domenenavn pekte på en Vultr-forekomst ( taskd.example.com )

Trinn 1: Oppdater systemet

Logg på som din sudo-bruker for å installere EPEL-depotet og oppdatere systemet som følger:

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

Trinn 2: Installer RPM Build og verktøy for bygging

EPEL-depotet inneholder ikke en RPM for TaskServer (taskd), så vi må bygge den fra kilden til en RPM-pakke selv.

1. Installer GCC, Make, RPM Build, utvikling og signeringsverktøy.

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

2. Lag en GnuPG-katalog som vil inneholde GPG-filene som er nødvendige for å signere RPM-en vår.

   mkdir .gnupg
   

3. Når du oppretter en nøkkel, krever vi entropi i systemet for å randomisere den på riktig måte. Den rngdnissen genererer entropi nødvendig fra /dev/urandom. Så la oss installere det nå.

   yum install rngd -y
   

4. Start opp rngddemonen for å generere entropi. Alternativet -r peker på i /dev/urandomstedet for standard /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Generer en nøkkel. Den --gen-key alternativet forteller gpg å generere et nytt nøkkelpar.

   gpg --gen-key
   

6. For alternativet " Vennligst velg hva slags nøkkel du vil ha: ", velg " (1) RSA og RSA (standard) " for nøkkeltypen ved å skrive inn 1 og trykke på Retur/Enter- tasten.

7. For alternativet " Hvilken nøkkelstørrelse vil du ha? (2048) " velger du standard ved å trykke på Retur/Enter- tasten.

8. For alternativet " Vennligst spesifiser hvor lenge nøkkelen skal være gyldig ", velg standard ved å trykke på Retur/Enter- tasten.

9. For " Er dette riktig? (y/N) "-alternativet, skriv inn y og trykk på Retur/Enter- tasten.

10. Under " Ekte navn: ", skriv inn et navn du velger og trykk på Retur/Enter- tasten.

11. Under " E-postadresse: ", skriv inn en e-postadresse du velger og trykk på Retur/Enter- tasten.

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

13. Gjør nødvendige endringer hvis du ikke har skrevet inn informasjonen din riktig. Hvis du er fornøyd med USER-ID- informasjonen som vises, skriv inn O (stor bokstav O, ikke null) og trykk på Retur/Enter- tasten.

14. GnuPG vil nå be deg om å opprette og bekrefte et passord for nøkkelparet ditt.

15. Etter at du har skrevet inn passordene dine, vil GnuPG-nøkkelparet ditt opprettes under .gnupgkatalogen i brukerkatalogen din.

16. Kjør denne kommandoen for å vise innholdet i .gnupgkatalogen. Den bør inneholde følgende katalog private-keys-v1.dog filer pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Eksporter det opprettede nøkkelparet. Alternativet --export instruerer GnuPG om å eksportere nøkkelparet. Alternativet -a instruerer GnuPG å sende ut nøkkelparet i ascii armor-format . Erstatt " Joe Q. Public " med navnet du skrev inn når du opprettet nøkkelparet i trinn #10 ovenfor. Erstatt " jqpublic " med den teksten du velger.

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

18. Importer nøkkelparet til RPM-nøkkellageret. Erstatt " jqpublic " med teksten du valgte i trinn #17.

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

19. Bekreft at nøkkelparet ble lagt til RPM-nøkkellageret. Den -Q gpg-pubkey alternativ spør RPM GnuPG keystore. Det % {name} -% {version} -% {frigivelse} ->% {Sammendrag} \ n vises resultatet i en menneskelig lesbart format.

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

20. Ved å opprette en .rpmmacros file, kan RPM tilpasses for å utføre tildelt atferd (eksempel: forenkle automatisk signering av RPM). Bruk nanoprogrammet til å lage filen.

    nano .rpmmacros
    

21. Deretter legger du til 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. Lagre dokumentet ved å angi følgende tastaturkombinasjoner. De CTRL + X Keys. Deretter S- tasten. Til slutt, Return/Enter- tasten.

23. Denne kommandoen nedenfor vil sette opp RPM-byggemiljøet ditt. Dette vil legge til flere makroer til .rpmmacrosfilen du har opprettet i trinn #20 og opprette de nødvendige katalogene for å bygge og lagre RPM-er.

    rpmdev-setuptree
    

24. Kjør denne kommandoen for å vise innholdet i rpmbuild-katalogen. Den bør inneholde følgende kataloger KILDER , RPMS , BUILD , SRPMS og SPECS .

    find rpmbuild
    

25. Last ned TaskServer (taskd) kildekoden til rpmbuild/SOURCESkatalogen.

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

26. Drep den løpende rgndprosessen.

    sudo kill -9 rngd
    

Trinn 3: Bygg TaskServer (taskd) RPM fra kilden

1. For å bygge en ny RPM fra kilden, må en TaskServer (taskd) SPEC-fil opprettes.

   nano rpmbuild/SPECS/taskd.spec
   

2. Legg til 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 <[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. Etter omstart, åpne en ledetekst og skriv inn følgende kommando bash . Dette vil installere Ubuntu på Windows. Trykk på Y-tasten . Den vil nå lastes ned og pakkes ut. Velg brukernavn og passord.

   bash
   

3. Nå er det på tide å installere TaskWarrior (oppgave). Skriv inn følgende kommando inne i konsollen.

   sudo apt-get install task -y
   

4. Skriv exit to ganger for å gå ut av bash-terminalen og Windows-ledeteksten.

5. Klikk på Start-meny-knappen. Skriv ubuntu . Høyreklikk på Bash på Ubuntu på Windows . Velg Fest til oppgavelinjen . Dette gir enkel tilgang til bash for å få tilgang til TaskWarrior (oppgave).

6. Klikk på Ubuntu-ikonet du nettopp har opprettet på oppgavelinjen. Dette åpner et terminalvindu som kjører Bash. Skriv inn følgende kommando nedenfor for å opprette TaskWarrior (oppgave) datakatalog ( ~/.task/) og konfigurasjonsfil ( .taskrc).

   task version
   yes
   

7. Du må flytte certificates.zipfilen du har lagret tidligere under TaskServer-oppsettet til ~/.taskd/katalogen inne i brukerkatalogen din. For å pakke ut filene fra zip-filen, installer unzipprogrammet først. Kopier og lim inn følgende kommandoer nedenfor og erstatte den faktiske plasseringen av kopien din av certificates.zip.

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

8. Skriv inn følgende kommandoer for å sette TaskWarrior (oppgave) opp for å koble til TaskServer (taskd). Erstatt NAME med det du har kalt sertifikatet og nøkkelen, GROUP med gruppen du har opprettet, Joe Q. Public med brukernavnet du har opprettet og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX med nøkkelen som ble tildelt når brukeren din ble opprettet 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. Nå er det på tide å synkronisere TaskWarrior (oppgave) med TaskServer (taskd). Kjør kommandoen nedenfor for å initialisere databasen.

   task sync init
   

   Synkronisering mellom TaskWarrior (oppgave)-klienten og TaskServer (taskd) er nå konfigurert på Windows 10-plattformen.

Android

For å bruke TaskWarrior (oppgave) på Android, må du installere TaskWarrior For Android fra Google Play Store.

1. Installer TaskWarrior (oppgave) For Android-appen på Googles Play Store.

2. Åpne TaskWarrior (oppgave) For Android-appen.

3. Du vil bli bedt av appen om å opprette en konto med et ønsket kontonavn . Skriv inn navnet du valgte da du opprettet et brukernavn for en TaskServer (taskd) bruker.

4. La datamappen stå på standardinnstillingen <<Opprett ny>> og trykk på OK- knappen. Bruk en filbehandlingsapp for å opprette en mappe i lagringsroten din (for eksempel: /storage/emulate/0/Certs). Send appen til bakgrunnen.

5. Kopier certificates.zipfilen du har opprettet tidligere og pakk ut innholdet i katalogen du opprettet i trinn #4.

6. Forgrunn appen "TaskWarrior (oppgave) For Android" og trykk på menyen øverst til venstre i appen for å åpne den.

7. Rull ned til bunnen av menyen og trykk på Innstillinger- alternativet.

8. Dette vil åpne en enkel innebygd TaskWarrior For Android-apptekstredigerer.

9. Angi følgende alternativer for å sette opp synkronisering med oppgaveserveren (taskd). Bytt ut taskd.ca/ taskd.certificate/ taskd.key` variabler med selve CA / sertifikat / nøkkel katalogbanen (s), NAVN med hva du heter sertifikatet og nøkkelen, GRUPPE med gruppen du opprettet, Joe Q. Public med brukernavnet du opprettet og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX med nøkkelen som ble tildelt da du opprettet brukeren din på TaskWarrior (taskd)-serveren.

   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. Trykk på diskettikonet for å lagre innstillingene.

Synkronisering mellom TaskWarrior (oppgave)-klienten og TaskServer (taskd) er nå konfigurert på Android-plattformen.

Linux

1. Se TaskWarrior (oppgave) distribusjonsseksjonen for å installere for din spesifikke Linux-distribusjon .

2. Åpne et terminalvindu. Skriv inn følgende kommando nedenfor for å opprette TaskWarrior (oppgave) datakatalog ( ~/.task/) og konfigurasjonsfil ( .taskrc).

   task version
   yes
   

3. Du må flytte certificates.zipfilen du har lagret tidligere i TaskServer-oppsettet til ~/.taskd/katalogen inne i brukerkatalogen din. For å pakke ut filene fra zip-filen, installer unzipførst programmet for din spesielle distribusjon. Kopier og lim inn følgende kommandoer nedenfor, og erstatte den faktiske plasseringen av din kopi av certificates.zip.

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

4. Skriv inn følgende kommandoer for å sette TaskWarrior (oppgave) opp for å koble til TaskServer (taskd). Erstatt NAME med det du har kalt sertifikatet og nøkkelen, GROUP med gruppen du har opprettet, Joe Q. Public med brukernavnet du har opprettet og XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX med nøkkelen som ble tildelt når brukeren din ble opprettet på TaskWarrior-serveren (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. Nå er det på tide å synkronisere TaskWarrior (oppgave) med TaskServer (taskd). Kjør kommandoen nedenfor for å initialisere databasen.

   task sync init
   

Tillegg: Hvis du kjører Gnome Shell, er det en utvidelse kalt TaskWhisper som integreres med TaskWarrior (oppgave).

Synkronisering mellom TaskWarrior (oppgave)-klienten og TaskServer (taskd) er nå satt opp på din favoritt Linux-distro.