Telepítse a TaskServer-t (taskd) a CentOS 7 rendszeren

A TaskWarrior egy nyílt forráskódú időkezelő eszköz, amely a Todo.txt alkalmazás és klónjai továbbfejlesztése. Tekintettel arra, hogy az átlagember több eszközt/platformot használ a napi beosztása során, kritikus fontosságú, hogy rendelkezzen egy központi adattárral, ahol az adatok bármely eszközről elérhetők és frissíthetők. Ez az oktatóanyag mind a TaskServer (taskd) kiszolgáló, mind a TaskWarrior (feladat) nevű kliens beállítására összpontosít, lehetővé téve több ügyféleszköz számára az adatok biztonságos elérését és cseréjét.

A következő tulajdonságokkal rendelkezik:

• Korlátlan számú feladat
• Feladatok rangsorolása
• Keresési szűrés
• Címkézés
• Automatikus szinkronizálás
• Automatikus biztonsági mentés
• Teljes ellenőrzés és adatvédelem
• Titkosított kommunikáció

Előfeltételek

• Egy CentOS 7 x64 szerverpéldány.
• A sudo felhasználó.
• A tartománynév egy Vultr példányra mutatott ( taskd.example.com )

1. lépés: Frissítse a rendszert

Jelentkezzen be sudo felhasználóként az EPEL Repository telepítéséhez és a rendszer frissítéséhez az alábbiak szerint:

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

2. lépés: Telepítse az RPM Build programot és az építkezéshez szükséges eszközöket

Az EPEL repository nem tartalmaz RPM-et a TaskServerhez (taskd), ezért magunknak kell azt forrásból RPM-csomagba építeni.

1. Telepítse a GCC, Make, RPM Build, fejlesztő és aláírási eszközöket.

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

2. Hozzon létre egy GnuPG könyvtárat, amely tartalmazza az RPM aláírásához szükséges GPG fájlokat.

   mkdir .gnupg
   

3. Kulcs létrehozásakor entrópiára van szükségünk a rendszerben, hogy megfelelően véletlenszerű legyen. A rngddémon a szükséges entrópiát generálja a -ból /dev/urandom. Tehát most telepítsük.

   yum install rngd -y
   

4. Indítsa el a rngddémont az entrópia generálásához. Az -r opció /dev/urandomaz alapértelmezett helyett a -ra mutat /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Kulcs létrehozása. A --gen-key opció arra utasítja a gpg-t, hogy hozzon létre egy új kulcspárt.

   gpg --gen-key
   

6. A " Kérjük, válassza ki, milyen kulcsot szeretne: " opciónál válassza ki a kulcstípusnak az " (1) RSA és RSA (alapértelmezett) " lehetőséget az 1 beírásával és a Return/Enter billentyű megnyomásával.

7. A " Milyen kulcsméretet szeretnél? (2048) " opciónál válassza ki az alapértelmezettet a Return/Enter billentyű megnyomásával.

8. A " Kérjük, adja meg, mennyi ideig legyen érvényes a kulcs. " opciónál válassza ki az alapértelmezett értéket a Return/Enter billentyű megnyomásával.

9. Az " Igaz ez? (y/N) " opcióhoz írja be az y-t, és nyomja meg a Return/Enter billentyűt.

10. A " Valódi név: " alatt írjon be egy választott nevet, és nyomja meg a Return/Enter billentyűt.

11. Az " E-mail cím: " alatt írjon be egy választott e-mail címet, és nyomja meg a Return/Enter billentyűt.

12. A Megjegyzés: rész üresen hagyható, ha úgy dönt.

13. Hajtsa végre a szükséges módosításokat, ha nem adta meg megfelelően az adatokat. Ha elégedett a megjelenített FELHASZNÁLÓI ID információval, írja be az O-t (nagy O betű, nem nulla), és nyomja meg a Return/Enter billentyűt.

14. A GnuPG most felkéri, hogy hozzon létre és erősítsen meg egy jelszót a kulcspárhoz.

15. Miután megadtad jelszavaidat, a GnuPG kulcspárod létrejön .gnupga felhasználói könyvtáradban található könyvtárban.

16. Futtassa ezt a parancsot a .gnupgkönyvtár tartalmának megjelenítéséhez . Tartalmaznia kell a következő könyvtárat private-keys-v1.dés fájlokat pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportálja a létrehozott kulcspárt. Az --export opció a kulcspár exportálására utasítja a GnuPG-t. Az -a opció arra utasítja a GnuPG-t, hogy a kulcspárt ascii armor formátumban adja ki . Cserélje ki a " Joe Q. Public " szót azzal a névvel, amelyet a fenti 10. lépésben a kulcspár létrehozásakor megadott. Cserélje le a " jqpublic " szöveget a választott szöveggel.

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

18. Importálja a kulcspárt az RPM kulcstárba. Cserélje ki a " jqpublic " szót a 17. lépésben kiválasztott szöveggel.

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

19. Ellenőrizze, hogy a kulcspár hozzáadásra került-e az RPM-kulcstárhoz. A --q gpg-pubkey opció lekérdezi az RPM GnuPG kulcstárat. A %{name}-%{version}-%{release} --> %{summary}\n az eredményt ember által olvasható formátumban jeleníti meg.

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

20. A létrehozásával az .rpmmacros fileRPM testreszabható a hozzárendelt viselkedések végrehajtására (például: az RPM-ek automatikus aláírásának megkönnyítése). Használja a nanoprogramot a fájl létrehozásához.

    nano .rpmmacros
    

21. Ezután adja hozzá az alábbi szöveget a .rpmmacrosfájlhoz.

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

22. Mentse el a dokumentumot a következő billentyűkombinációk beírásával. A CTRL + X billentyűk. Aztán az S kulcs. Végül a Return/Enter gomb.

23. Ez az alábbi parancs beállítja az RPM-építési környezetet. Ez további makrókat fűz a .rpmmacros20. lépésben létrehozott fájlhoz, és létrehozza az RPM-ek létrehozásához és tárolásához szükséges könyvtárakat.

    rpmdev-setuptree
    

24. Futtassa ezt a parancsot az rpmbuild könyvtár tartalmának megjelenítéséhez. A következő könyvtárakat kell tartalmaznia: SOURCES , RPMS , BUILD , SRPMS és SPECS .

    find rpmbuild
    

25. Töltse le a TaskServer (taskd) forráskódját a rpmbuild/SOURCESkönyvtárba.

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

26. Öld meg a futó rgndfolyamatot.

    sudo kill -9 rngd
    

3. lépés: A TaskServer (taskd) RPM létrehozása a forrásból

1. Új RPM forrásból történő létrehozásához létre kell hozni egy TaskServer (taskd) SPEC fájlt.

   nano rpmbuild/SPECS/taskd.spec
   

2. Adja hozzá az alábbi szöveget a taskd.specfájlhoz.

   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. Az újraindítás után nyisson meg egy parancssort, és írja be a következő parancsot: bash . Ez telepíti az Ubuntut a Windows rendszerre. Nyomja meg az Y gombot . Most letöltődik és kicsomagolja. Válasszon felhasználónevet és jelszót.

   bash
   

3. Itt az ideje a TaskWarrior (feladat) telepítésének. Írja be a következő parancsot a konzolba.

   sudo apt-get install task -y
   

4. A bash terminálból és a Windows parancssorból való kilépéshez írja be kétszer az exit parancsot.

5. Kattintson a Start menü gombra. Írd be, hogy ubuntu . Kattintson jobb gombbal a Bash elemre az Ubuntu rendszeren Windows rendszeren . Válassza a Rögzítés a tálcára lehetőséget . Ez kényelmessé teszi a bash gyors elérését a TaskWarrior (feladat) eléréséhez.

6. Kattintson az imént létrehozott Ubuntu ikonra a tálcán. Ezzel megnyílik a Bash-t futtató terminálablak. Írja be az alábbi parancsot a TaskWarrior (feladat) adatkönyvtár ( ~/.task/) és konfigurációs fájl ( .taskrc) létrehozásához.

   task version
   yes
   

7. A certificates.zipkorábban a TaskServer beállítása során elmentett fájlt át kell helyeznie a ~/.taskd/felhasználói címtáron belüli könyvtárba. A fájlok zip fájlból való kicsomagolásához unzipelőször telepítse a programot. Másolja és illessze be az alábbi parancsokat, amelyek helyettesítik a másolatának tényleges helyét certificates.zip.

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

8. Írja be a következő parancsokat a TaskWarrior (task) beállításához, hogy csatlakozzon a TaskServerhez (taskd). Cserélje le a( z) NAME nevet arra, amit a tanúsítványának és kulcsának elnevezett, a GROUP mezőt az Ön által létrehozott csoportra, Joe Q. Public (Nyilvános) az Ön által létrehozott felhasználónévvel, a XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX pedig a felhasználó által hozzárendelt kulccsal a TaskWarrior (taskd) szerveren jött létre.

   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. Itt az ideje a TaskWarrior (feladat) szinkronizálásának a TaskServerrel (taskd). Futtassa az alábbi parancsot az adatbázis inicializálásához.

   task sync init
   

   A TaskWarrior (feladat) kliens és a TaskServer (taskd) közötti szinkronizálás most be van állítva a Windows 10 platformon.

Android

A TaskWarrior (feladat) Androidon való használatához telepítenie kell a TaskWarrior For Android alkalmazást a Google Play Áruházból.

1. Telepítse a TaskWarrior (task) For Android alkalmazást a Google Play Áruházból.

2. Nyissa meg a TaskWarrior (task) For Android alkalmazást.

3. Az alkalmazás arra kéri, hogy hozzon létre egy fiókot a kívánt fióknévvel . Adja meg azt a nevet, amelyet a TaskServer (taskd) felhasználó felhasználónevének létrehozásakor választott.

4. Hagyja az adatmappát az alapértelmezett <<Új létrehozása>> beállításra, és érintse meg az OK gombot. Fájlkezelő alkalmazással hozzon létre egy mappát a tárhely gyökérben (például: /storage/emulate/0/Certs). Küldje el az alkalmazást a háttérbe.

5. Másolja ki a certificates.zipkorábban létrehozott fájlt, és bontsa ki a tartalmát a 4. lépésben létrehozott könyvtárába.

6. Tegye előtérben a „TaskWarrior (task) For Android” alkalmazást, és érintse meg a menüt az alkalmazás bal felső sarkában annak megnyitásához.

7. Görgessen le a menü aljára, és érintse meg a Beállítások lehetőséget.

8. Ezzel megnyílik egy egyszerű beépített TaskWarrior For Android alkalmazás szövegszerkesztője.

9. Adja meg a következő beállításokat a TaskServerrel (taskd) való szinkronizálás beállításához. Cserélje ki a taskd.ca/ taskd.certificate/taskd.key` változókat a tényleges ca/certificate/key könyvtár elérési útjával, a NAME változót azzal , amit a tanúsítványának és kulcsának elnevezett, a GROUP értéket a létrehozott csoporttal, Joe Q. Public a létrehozott felhasználónévvel és XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX azzal a kulccsal, amely a TaskWarrior (taskd) szerveren a felhasználó létrehozásakor lett hozzárendelve.

   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. A beállítások mentéséhez érintse meg a hajlékonylemez ikont.

A TaskWarrior (feladat) kliens és a TaskServer (taskd) közötti szinkronizálás most be van állítva az Android platformon.

Linux

1. Tekintse meg a TaskWarrior (feladat) terjesztési szakaszt az adott Linux disztribúcióhoz való telepítéshez .

2. Nyisson meg egy terminál ablakot. Írja be az alábbi parancsot a TaskWarrior (feladat) adatkönyvtár ( ~/.task/) és konfigurációs fájl ( .taskrc) létrehozásához.

   task version
   yes
   

3. A certificates.zipTaskServer beállításaiban korábban elmentett fájlt át kell helyeznie a ~/.taskd/felhasználói címtáron belüli könyvtárba. A fájlok zip fájlból való kibontásához unzipelőször telepítse a programot az adott disztribúcióhoz. Másolja és illessze be az alábbi parancsokat, helyettesítve ezzel a másolatának tényleges helyét certificates.zip.

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

4. Írja be a következő parancsokat a TaskWarrior (task) beállításához, hogy csatlakozzon a TaskServerhez (taskd). Cserélje le a( z) NAME nevet arra, amit a tanúsítványának és kulcsának elnevezett, a GROUP mezőt az Ön által létrehozott csoportra, Joe Q. Public (Nyilvános) az Ön által létrehozott felhasználónévvel, a XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX pedig a felhasználó által hozzárendelt kulccsal a TaskWarrior (taskd) szerveren jött létre.

   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. Itt az ideje a TaskWarrior (feladat) szinkronizálásának a TaskServerrel (taskd). Futtassa az alábbi parancsot az adatbázis inicializálásához.

   task sync init
   

Kiegészítés: Ha a Gnome Shell-t futtatja, van egy TaskWhisper nevű bővítmény, amely integrálódik a TaskWarriorral (feladat).

A TaskWarrior (feladat) kliens és a TaskServer (taskd) közötti szinkronizálás most be van állítva kedvenc Linux disztribúcióján.