Installer TaskServer (taskd) sur CentOS 7

TaskWarrior est un outil de gestion du temps open source qui est une amélioration de l'application Todo.txt et de ses clones. En raison du fait que la personne moyenne utilise plusieurs appareils / plates-formes dans son horaire quotidien, il est essentiel d'avoir la possibilité d'avoir un référentiel centralisé où les données peuvent être consultées et mises à jour à partir de n'importe quel appareil. Ce didacticiel se concentrera sur la configuration du serveur, appelé TaskServer (taskd), et du client, appelé TaskWarrior (task), permettant à plusieurs périphériques clients d'accéder et d'échanger des données en toute sécurité.

Il présente les caractéristiques suivantes:

• Tâches illimitées
• Priorité des tâches
• Filtrage de recherche
• Marquage
• Synchronisation automatique
• Sauvegarde automatique
• Contrôle total et confidentialité
• Communication cryptée

Conditions préalables

• Une instance de serveur CentOS 7 x64.
• Un utilisateur sudo .
• Le nom de domaine pointe vers une instance Vultr (taskd.example.com)

Étape 1: mettre à jour le système

Connectez-vous en tant qu'utilisateur sudo pour installer le référentiel EPEL et mettre à jour le système comme suit:

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

Étape 2: installer RPM Build et les outils de construction

Le référentiel EPEL ne contient pas de RPM pour le TaskServer (taskd), nous devons donc le construire nous-mêmes depuis la source dans un package RPM.

1. Installez les outils GCC, Make, RPM Build, développement et signature.

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

2. Créez un répertoire GnuPG qui contiendra les fichiers GPG nécessaires à la signature de notre RPM.

   mkdir .gnupg
   

3. Lors de la création d'une clé, nous avons besoin d'une entropie dans le système pour la randomiser correctement. Le rngddémon génère l'entropie nécessaire à partir de /dev/urandom. Alors installons ça maintenant.

   yum install rngd -y
   

4. Démarrez le rngddémon pour générer l'entropie. L' option -r pointe sur au /dev/urandomlieu de la valeur par défaut /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Générez une clé. L' option --gen-key indique à gpg de générer une nouvelle paire de clés.

   gpg --gen-key
   

6. Pour l' option " Veuillez sélectionner le type de clé que vous souhaitez: ", sélectionnez " (1) RSA et RSA (par défaut) " pour le type de clé en saisissant 1 et en appuyant sur la touche Entrée / Retour .

7. Pour l' option " Quelle taille de clé voulez-vous? (2048) ", choisissez la valeur par défaut en appuyant sur la touche Entrée / Retour .

8. Pour l' option « Veuillez spécifier la durée de validité de la clé », choisissez la valeur par défaut en appuyant sur la touche Retour / Entrée .

9. Pour l' option " Est-ce correct? (O / N) ", saisissez y et appuyez sur la touche Entrée / Retour .

10. Sous " Nom réel: ", entrez le nom de votre choix et appuyez sur la touche Entrée / Retour .

11. Sous " Adresse e-mail: ", entrez une adresse e-mail de votre choix et appuyez sur la touche Retour / Entrée .

12. La section Commentaire: peut être laissée vierge si vous le souhaitez.

13. Apportez les modifications nécessaires si vous n'avez pas entré correctement vos informations. Si vous êtes satisfait des informations ID UTILISATEUR affichées, entrez O (lettre majuscule O, pas zéro) et appuyez sur la touche Retour / Entrée .

14. GnuPG vous demandera maintenant de créer et de vérifier un mot de passe pour votre paire de clés.

15. Après avoir entré vos mots de passe, votre paire de clés GnuPG sera créée sous le .gnupgrépertoire de votre répertoire utilisateur.

16. Exécutez cette commande pour afficher le contenu du .gnupgrépertoire. Elle doit contenir le répertoire suivant private-keys-v1.det les fichiers pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exportez la paire de clés créée. L' option --export demande à GnuPG d'exporter la paire de clés. L' option -a demande à GnuPG de sortir la paire de clés au format d'armure ascii . Remplacez « Joe Q. Public » par le nom que vous avez entré lors de la création de la paire de clés à l'étape 10 ci-dessus. Remplacez " jqpublic " par le texte que vous choisissez.

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

18. Importez la paire de clés dans le magasin de clés RPM. Remplacez " jqpublic " par le texte que vous avez choisi à l'étape 17.

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

19. Vérifiez que la paire de clés a été ajoutée au magasin de clés RPM. L' option --q gpg-pubkey interroge le magasin de clés RPM GnuPG. Le % {name} -% {version} -% {version} -> {%} résumé \ n affiche le résultat dans un format lisible par l' homme.

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

20. En créant un .rpmmacros file, les RPM peuvent être personnalisés pour effectuer les comportements attribués (exemple: faciliter la signature automatique des RPM). Utilisez le nanoprogramme pour créer le fichier.

    nano .rpmmacros
    

21. Ensuite, ajoutez le texte suivant ci-dessous dans le .rpmmacrosfichier.

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

22. Enregistrez le document en entrant les combinaisons de touches suivantes. Les CTRL + X Keys. Ensuite, la touche S. Enfin, la touche Entrée / Retour .

23. Cette commande ci-dessous configurera votre environnement de génération RPM. Cela ajoutera des macros supplémentaires au .rpmmacrosfichier que vous avez créé à l'étape # 20 et créera les répertoires requis pour créer et stocker les RPM.

    rpmdev-setuptree
    

24. Exécutez cette commande pour afficher le contenu du répertoire rpmbuild. Il doit contenir les répertoires suivants SOURCES , RPMS , BUILD , SRPMS et SPECS .

    find rpmbuild
    

25. Téléchargez le code source de TaskServer (taskd) dans le rpmbuild/SOURCESrépertoire.

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

26. Tuez le rgndprocessus en cours.

    sudo kill -9 rngd
    

Étape 3: créer un RPM TaskServer (taskd) à partir de la source

1. Afin de créer un nouveau RPM à partir de la source, un fichier SPEC TaskServer (taskd) doit être créé.

   nano rpmbuild/SPECS/taskd.spec
   

2. Ajoutez le texte suivant ci-dessous dans le taskd.specfichier.

   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. Le RPM nécessite également trois fichiers supplémentaires qui doivent être créés dans le rpmbuild/SOURCESrépertoire. Utilisez le nanoprogramme pour créer le taskd-configfichier.

   nano rpmbuild/SOURCES/taskd-config
   

4. Ajoutez le texte suivant ci-dessous dans le taskd-configfichier.

   # 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. Utilisez le nanoprogramme pour créer le taskd.servicefichier.

   nano rpmbuild/SOURCES/taskd.service
   

6. Ajoutez le texte suivant ci-dessous dans le taskd.servicefichier.

   [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. Utilisez le nanoprogramme pour créer le taskd.xmlfichier.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Ajoutez le texte suivant ci-dessous dans le taskd.xmlfichier.

   <?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. Afin de construire le RPM TaskServer (taskd), trois packages sont requis pour la construction. Exécutez la commande ci-dessous pour installer ces packages.

   sudo yum install cmake libuuid-devel gnutls-devel gnutls-utils -y
   

10. Il est maintenant temps de construire à partir de la source et de créer un RPM pour TaskServer (taskd). Exécutez les commandes ci-dessous pour commencer. La construction des RPM devrait prendre moins d'une minute sur une instance Vultr 1x CPU. Entrez le mot de passe GnuPG que vous avez créé à l'étape 14 pour signer le RPM lorsque vous y êtes invité.

    cd rpmbuild/SPECS/
    rpm -ba -sign taskd.spec
    

11. Installez le RPM TaskServer (taskd).

    cd
    sudo rpm -ivh rpmbuild/RPMS/x86_64/taskd-1.1.0-1.el7.centos.x86_64.rpm
    

Étape 4: configurer TaskServer (tâche)

1. Pour que TaskServer (taskd) communique et se synchronise avec les clients TaskWarrior (task), vous devrez utiliser les scripts de génération trouvés sous /etc/pki/taskd/pour générer des certificats / clés de serveur et de client. Accédez à l'utilisateur root à l'aide de la commande ci-dessous et changez de répertoire en /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Utilisez le nanoprogramme pour créer un varsfichier afin de générer une autorité de certification racine auto-signée.

   nano vars
   

   Ajoutez le texte suivant ci-dessous dans le fichier vars. Changez ORGANISATION , CN , PAYS , ÉTAT et LOCALITÉ à votre satisfaction.

   BITS=4096
   EXPIRATION_DAYS=365
   ORGANIZATION="Vultr.com Inc."
   CN=taskd.example.com
   COUNTRY=US
   STATE="New York"
   LOCALITY="New York"
   

3. Générez l'autorité de certification racine auto-signée, le certificat, la clé du serveur et la liste de révocation du serveur (facultatif).

   ./generate.ca
   ./generate.server
   ./generate.crl
   

   Ces commandes vont créer les fichiers suivants ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemet server.crl.pem) à l' intérieur du /etc/pki/taskd/répertoire. Pour que TaskServer (taskd) démarre, la propriété et les autorisations sur les certificats et les clés générés à l'étape # 37 doivent être modifiées pour permettre à TaskServer (taskd) d'y accéder. Exécutez les commandes ci-dessous pour les modifier.

   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. Activez et démarrez le démon TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Ouvrez le port dans le pare-feu sur lequel fonctionne TaskServer (taskd).

   firewall-cmd --permanent --zone=public --add-port=53589/tcp
   firewall-cmd --reload
   

   TaskServer (taskd) est maintenant installé et configuré sur votre instance CentOS 7.

Étape 5: configurer le certificat et la clé du client TaskWarrior

1. Vous devez créer des certificats clients et une clé pour crypter les communications entre TaskServer (taskd) et TaskWarrior (task). Exécutez la commande ci-dessous pour générer un certificat client et une clé. Remplacez-le NAMEpar un nom que vous pouvez facilement reconnaître pour votre client.

   generate.client NAME
   

   Cette commande créera les fichiers suivants ( NAME.cert.pem, NAME.key.pem) à l'intérieur du /etc/pki/taskd/répertoire.

2. Copiez les fichiers suivants dans votre répertoire utilisateur, modifiez la propriété et les autorisations. Remplacez joeqpublic ci-dessous par votre répertoire de nom d'utilisateur réel.

   cp ca.cert.pem NAME.cert.pem NAME.key.pem /home/joeqpublic/
   chown joeqpublic.joeqpublic /home/joeqpublic/*.pem
   chmod 400 /home/joeqpublic/*.pem
   

3. Créez une archive zip des certificats et de la clé.

   zip certficates.zip ca.cert.pem NAME.cert.pem NAME.key.pem
   

4. Utilisez scp(ligne de commande) ou WinSCP (interface graphique pour SCP) pour télécharger le certificates.zipfichier de votre instance CentOS vers votre appareil client (ordinateur / ordinateur portable / smartphone).

5. Supprimez les privilèges root et exécutez le reste de vos commandes en tant qu'utilisateur normal.

   exit
   

   TaskServer (taskd) est maintenant configuré et prêt pour la connexion des clients TaskWarrior (task).

Étape 6: Créez votre premier groupe et utilisateur TaskWarrior

1. Pour créer, supprimer, modifier et synchroniser vos tâches, vous aurez besoin d'un compte utilisateur. Cependant, avant de pouvoir ajouter des utilisateurs, vous devez d'abord créer un groupe d'organisation. Exécutez la commande ci-dessous pour créer votre premier groupe. Remplacez GROUP par un nom facilement reconnaissable.

2. IMPORTANT! La taskdcommande pour créer des groupes / utilisateurs doit être exécutée en tant taskdqu'utilisateur. L'exécution en tant qu'utilisateur root créera des répertoires et des fichiers appartenant à l'utilisateur root sous /var/lib/taskd/orgslesquels les clients TaskWarrior (tâche) ne pourront pas accéder ou modifier quoi que ce soit dans le groupe auquel ils ont été affectés. L'accès sera refusé.

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

3. Maintenant que vous avez créé votre premier groupe, créons notre premier utilisateur. Exécutez la commande ci-dessous pour créer un utilisateur affecté au groupe créé à l'étape # 1. Copiez et collez la clé utilisateur, l'utilisateur et le groupe générés dans un fichier texte. Répétez le processus pour ajouter des utilisateurs supplémentaires.

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

Étape 7: installer les clients TaskWarrior

Windows 10 (version ultérieure à 1607+)

Pour utiliser TaskWarrior (tâche) sur Windows 10, vous devez installer le sous-système Windows pour Linux à partir du Windows Store.

1. Pour installer WSL, une invite Powershell élevée est requise. Appuyez sur la touche Fenêtre et tapez PowerShell . Faites un clic droit sur Windows Powershell en haut des résultats et sélectionnez " Exécuter en tant qu'administrateur ". À l'invite Contrôle de compte d'utilisateur, cliquez sur Oui . Copiez et collez le texte ci-dessous dans les fenêtres Powershell. Une fois l'installation de WSL terminée, appuyez sur la touche Y pour redémarrer Windows.

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

2. Après le redémarrage, ouvrez une invite de commande et tapez la commande bash suivante . Cela installera Ubuntu sur Windows. Appuyez sur la touche Y . Il sera maintenant téléchargé et extrait. Choisissez un nom d'utilisateur et un mot de passe.

   bash
   

3. Il est maintenant temps d'installer TaskWarrior (tâche). Tapez la commande suivante dans la console.

   sudo apt-get install task -y
   

4. Tapez exit deux fois pour quitter le terminal bash et l'invite de commande Windows.

5. Cliquez sur le bouton Menu Démarrer. Tapez ubuntu . Faites un clic droit sur Bash sur Ubuntu sous Windows . Sélectionnez Épingler à la barre des tâches . Cela permet d'accéder rapidement à bash pour accéder à TaskWarrior (tâche).

6. Cliquez sur l'icône Ubuntu que vous venez de créer dans la barre des tâches. Cela ouvrira une fenêtre de terminal exécutant Bash. Tapez la commande suivante ci-dessous pour créer le répertoire de données TaskWarrior (tâche) ( ~/.task/) et le fichier de configuration ( .taskrc).

   task version
   yes
   

7. Vous devez déplacer le certificates.zipfichier que vous avez enregistré précédemment lors de l'installation de TaskServer dans le ~/.taskd/répertoire à l'intérieur de votre répertoire utilisateur. Pour extraire les fichiers du fichier zip, installez d'abord le unzipprogramme. Copiez et collez les commandes suivantes ci-dessous en remplaçant l'emplacement réel de votre copie de certificates.zip.

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

8. Tapez les commandes suivantes pour configurer TaskWarrior (tâche) pour se connecter à TaskServer (taskd). Remplacez NAME par ce que vous avez nommé votre certificat et votre clé, GROUP avec le groupe que vous avez créé, Joe Q. Public avec le nom d'utilisateur que vous avez créé et XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX avec la clé attribuée lorsque votre utilisateur a été créé sur le serveur TaskWarrior (taskd).

   task config taskd.ca -- ~/.task/ca.cert.pem
   task config taskd.certificate -- ~/.task/**NAME**.cert.pem
   task config taskd.key -- ~/.task/**NAME**.key.pem
   task config taskd.server -- taskd.example.com:53589
   task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX
   

9. Il est maintenant temps de synchroniser TaskWarrior (task) avec TaskServer (taskd). Exécutez la commande ci-dessous pour initialiser la base de données.

   task sync init
   

   La synchronisation entre votre client TaskWarrior (tâche) et le serveur TaskServer (taskd) est maintenant configurée sur la plate-forme Windows 10.

Android

Pour utiliser TaskWarrior (tâche) sur Android, vous devez installer TaskWarrior pour Android à partir du Google Play Store.

1. Installez l'application TaskWarrior (tâche) pour Android sur le Play Store de Google.

2. Ouvrez l'application TaskWarrior (tâche) pour Android.

3. L'application vous demandera de créer un compte avec un nom de compte souhaité . Entrez le nom que vous avez choisi lorsque vous avez créé un nom d'utilisateur pour un utilisateur TaskServer (taskd).

4. Laissez le dossier de données au paramètre par défaut de << Créer nouveau >> et appuyez sur le bouton OK . Utilisez une application de gestion de fichiers pour créer un dossier dans votre racine de stockage (par exemple:) /storage/emulate/0/Certs. Envoyez l'application en arrière-plan.

5. Copiez le certificates.zipfichier que vous avez créé précédemment et extrayez son contenu dans votre répertoire créé à l'étape # 4.

6. Mettez en avant l'application «TaskWarrior (tâche) pour Android» et appuyez sur le menu dans le coin supérieur gauche de l'application pour l'ouvrir.

7. Faites défiler vers le bas du menu et appuyez sur l' option Paramètres .

8. Cela ouvrira un simple éditeur de texte intégré à l'application TaskWarrior pour Android.

9. Entrez les options suivantes pour configurer la synchronisation avec votre TaskServer (taskd). Remplacez les variables taskd.ca/ taskd.certificate/ taskd.key` par le (s) chemin (s) réel (s) du répertoire ca / ​​certificate / key, NAME avec ce que vous avez nommé votre certificat et votre clé, GROUP avec le groupe que vous avez créé, Joe Q. Public avec le nom d'utilisateur que vous avez créé et XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX avec la clé attribuée lorsque vous avez créé votre utilisateur sur le serveur TaskWarrior (taskd).

   taskd.ca=/storage/emulate/0/Certs/ca.cert.pem
   taskd.certificate=/storage/emulate/0/Certs/NAME.cert.pem
   taskd.credentials=GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
   taskd.key=/storage/emulate/0/Certs/NAME.key.pem
   taskd.server=taskd.example.com:53589
   

10. Appuyez sur l'icône de la disquette pour enregistrer vos paramètres.

La synchronisation entre votre client TaskWarrior (tâche) et le serveur TaskServer (taskd) est maintenant configurée sur la plate-forme Android.

Linux

1. Reportez-vous à la section de distribution TaskWarrior (tâche) à installer pour votre distribution Linux particulière .

2. Ouvrez une fenêtre de terminal. Tapez la commande suivante ci-dessous pour créer le répertoire de données TaskWarrior (tâche) ( ~/.task/) et le fichier de configuration ( .taskrc).

   task version
   yes
   

3. Vous devez déplacer le certificates.zipfichier que vous avez enregistré précédemment dans la configuration de TaskServer vers le ~/.taskd/répertoire à l'intérieur de votre répertoire utilisateur. Pour extraire les fichiers du fichier zip, installez d'abord le unzipprogramme pour votre distribution particulière. Copiez et collez les commandes suivantes ci-dessous, en remplaçant l'emplacement réel de votre copie de certificates.zip.

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

4. Tapez les commandes suivantes pour configurer TaskWarrior (tâche) pour se connecter à TaskServer (taskd). Remplacez NAME par ce que vous avez nommé votre certificat et votre clé, GROUP avec le groupe que vous avez créé, Joe Q. Public avec le nom d'utilisateur que vous avez créé et XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX avec la clé attribuée lorsque votre utilisateur a été créé sur le serveur TaskWarrior (taskd).

   task config taskd.ca -- ~/.task/ca.cert.pem
   task config taskd.certificate -- ~/.task/**NAME**.cert.pem
   task config taskd.key -- ~/.task/**NAME**.key.pem
   task config taskd.server -- taskd.example.com:53589
   task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX
   

5. Il est maintenant temps de synchroniser TaskWarrior (task) avec TaskServer (taskd). Exécutez la commande ci-dessous pour initialiser la base de données.

   task sync init
   

Addendum: si vous exécutez Gnome Shell, il existe une extension appelée TaskWhisper qui s'intègre à TaskWarrior (tâche).

La synchronisation entre votre client TaskWarrior (tâche) et le serveur TaskServer (taskd) est maintenant configurée sur votre distribution Linux préférée.