Instalar TaskServer (taskd) en CentOS 7

TaskWarrior es una herramienta de gestión de tiempo de código abierto que es una mejora en la aplicación Todo.txt y sus clones. Debido al hecho de que la persona promedio usa múltiples dispositivos / plataformas en su horario diario, es fundamental tener la capacidad de tener un repositorio centralizado donde se pueda acceder y actualizar los datos desde cualquier dispositivo. Este tutorial se enfocará en configurar tanto el servidor, llamado TaskServer (taskd), como el cliente, llamado TaskWarrior (task), permitiendo que múltiples dispositivos cliente accedan e intercambien datos de manera segura.

Tiene las siguientes características:

• Tareas ilimitadas
• Priorización de tareas
• Filtrado de búsqueda
• Etiquetado
• Sincronización automática
• Copia de seguridad automática
• Control total y privacidad
• Comunicación encriptada

Prerrequisitos

• Una instancia de servidor CentOS 7 x64.
• Un usuario de sudo .
• Nombre de dominio apuntado a una instancia de Vultr (taskd.example.com)

Paso 1: actualiza el sistema

Inicie sesión como usuario de sudo para instalar el repositorio EPEL y actualizar el sistema de la siguiente manera:

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

Paso 2: Instale RPM Build y herramientas para construir

El repositorio EPEL no contiene un RPM para el TaskServer (taskd), por lo que tenemos que construirlo desde la fuente en un paquete RPM nosotros mismos.

1. Instale GCC, Make, RPM Build, herramientas de desarrollo y firma.

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

2. Cree un directorio GnuPG que contenga los archivos GPG necesarios para firmar nuestro RPM.

   mkdir .gnupg
   

3. Al crear una clave, requerimos entropía en el sistema para aleatorizarla correctamente. El rngddemonio genera la entropía necesaria a partir de /dev/urandom. Así que vamos a instalar eso ahora.

   yum install rngd -y
   

4. Inicia el rngddemonio para generar entropía. La opción -r apunta a en /dev/urandomlugar de la predeterminada /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Genera una clave. La opción --gen-key le dice a gpg que genere un nuevo par de claves.

   gpg --gen-key
   

6. Para la opción " Seleccione el tipo de clave que desea: ", seleccione " (1) RSA y RSA (predeterminado) " para el tipo de clave ingresando 1 y presionando la tecla Intro / Entrar .

7. Para la opción " ¿Qué tamaño de clave desea? (2048) ", elija el valor predeterminado presionando la tecla Intro / Entrar .

8. Para la opción " Especifique durante cuánto tiempo debe ser válida la clave ", elija la opción predeterminada presionando la tecla Intro / Entrar .

9. Para la opción " ¿Es esto correcto? (Y / N) ", ingrese y y presione la tecla Intro / Entrar .

10. En " Nombre real: ", ingrese el nombre que elija y presione la tecla Intro / Entrar .

11. En " Dirección de correo electrónico: ", ingrese una dirección de correo electrónico de su elección y presione la tecla Intro / Entrar .

12. La sección Comentario: puede dejarse en blanco si así lo elige.

13. Realice los cambios necesarios si no ingresó su información correctamente. Si está satisfecho con la información de ID de usuario que se muestra, ingrese O (letra mayúscula O, no cero) y presione la tecla Intro / Entrar .

14. GnuPG ahora le pedirá que cree y verifique una contraseña para su par de claves.

15. Después de haber ingresado sus contraseñas, su par de claves GnuPG se creará en el .gnupgdirectorio de su directorio de usuario.

16. Ejecute este comando para mostrar el contenido del .gnupgdirectorio. Debe contener el siguiente directorio private-keys-v1.dy los archivos pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exporte el par de claves creado. La opción --export le indica a GnuPG que exporte el par de claves. La opción -a indica a GnuPG que muestre el par de claves en formato de armadura ascii . Reemplace " Joe Q. Public " con el nombre que ingresó al crear el par de claves en el paso # 10 anterior. Reemplace " jqpublic " con el texto que elija.

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

18. Importe el par de claves en el almacén de claves RPM. Reemplace " jqpublic " con el texto que eligió en el paso # 17.

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

19. Verifique que el par de claves se haya agregado al almacén de claves RPM. La opción --q gpg-pubkey consulta el almacén de claves RPM GnuPG. El % {name} -% {version} -% {release} ->% {summary} \ n muestra el resultado en un formato legible para humanos.

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

20. Al crear un .rpmmacros file, RPM se puede personalizar para realizar los comportamientos asignados (ejemplo: facilitar la firma automática de RPM). Use el nanoprograma para crear el archivo.

    nano .rpmmacros
    

21. Luego, agregue el siguiente texto a continuación en el .rpmmacrosarchivo.

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

22. Guarde el documento ingresando las siguientes combinaciones de teclado. Los CTRL + X Llaves. Entonces, la tecla S. Finalmente, la tecla Intro / Entrar .

23. Este comando a continuación configurará su entorno de compilación RPM. Esto agregará macros adicionales al .rpmmacrosarchivo que ha creado en el paso # 20 y creará los directorios necesarios para construir y almacenar RPM.

    rpmdev-setuptree
    

24. Ejecute este comando para mostrar el contenido del directorio rpmbuild. Debe contener los siguientes directorios FUENTES , RPMS , BUILD , SRPMS y SPECS .

    find rpmbuild
    

25. Descargue el código fuente del TaskServer (taskd) en el rpmbuild/SOURCESdirectorio.

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

26. Mata el rgndproceso en ejecución .

    sudo kill -9 rngd
    

Paso 3: Construir RPM TaskServer (taskd) desde la fuente

1. Para construir un nuevo RPM desde la fuente, se debe crear un archivo SPEC TaskServer (taskd).

   nano rpmbuild/SPECS/taskd.spec
   

2. Agregue el siguiente texto a continuación en el taskd.specarchivo.

   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. El RPM también requiere tres archivos adicionales que deben crearse en el rpmbuild/SOURCESdirectorio. Use el nanoprograma para crear el taskd-configarchivo.

   nano rpmbuild/SOURCES/taskd-config
   

4. Agregue el siguiente texto a continuación en el taskd-configarchivo.

   # 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 el nanoprograma para crear el taskd.servicearchivo.

   nano rpmbuild/SOURCES/taskd.service
   

6. Agregue el siguiente texto a continuación en el taskd.servicearchivo.

   [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 el nanoprograma para crear el taskd.xmlarchivo.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Agregue el siguiente texto a continuación en el taskd.xmlarchivo.

   <?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. Para construir el RPM TaskServer (taskd), se requieren tres paquetes para la construcción. Ejecute el siguiente comando para instalar esos paquetes.

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

10. Ahora es el momento de construir desde la fuente y crear un RPM para TaskServer (taskd). Ejecute los siguientes comandos para comenzar. Debería tomar menos de un minuto en una instancia de CPU Vultr 1x para construir los RPM. Ingrese la contraseña de GnuPG que creó en el paso 14 para firmar el RPM cuando se le solicite.

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

11. Instale el RPM TaskServer (taskd).

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

Paso 4: Configurar TaskServer (tarea)

1. Para que TaskServer (taskd) se comunique y se sincronice con los clientes de TaskWarrior (task), deberá usar los scripts de generación que se encuentran debajo /etc/pki/taskd/para generar certificados / claves de servidor y cliente. Eleve al usuario raíz utilizando el comando a continuación y cambie el directorio a /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Use el nanoprograma para crear un varsarchivo para generar una CA raíz autofirmada.

   nano vars
   

   Agregue el siguiente texto a continuación en el archivo vars. Cambie ORGANIZACIÓN , CN , PAÍS , ESTADO y LOCALIDAD a su satisfacción.

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

3. Genere la CA raíz autofirmada, el certificado, la clave del servidor y la lista de revocación del servidor (opcional).

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

   Estos comandos crearán los siguientes archivos ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.pemy server.crl.pem) dentro del /etc/pki/taskd/directorio. Para que se inicie TaskServer (taskd), la propiedad y los permisos de los certificados y claves generados en el paso 37 deben modificarse para permitir que TaskServer (taskd) acceda a ellos. Ejecute los siguientes comandos para cambiarlos.

   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. Habilite e inicie el demonio TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Abra el puerto en el firewall en el que se ejecuta TaskServer (taskd).

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

   TaskServer (taskd) ahora está instalado y configurado en su instancia de CentOS 7.

Paso 5: Configurar el certificado y la clave del cliente TaskWarrior

1. Debe crear certificados de cliente y clave para cifrar las comunicaciones entre TaskServer (taskd) y TaskWarrior (task). Ejecute el siguiente comando para generar un certificado de cliente y una clave. Reemplace NAMEcon un nombre que pueda reconocer fácilmente para su cliente.

   generate.client NAME
   

   Este comando creará los siguientes archivos ( NAME.cert.pem, NAME.key.pem) dentro del /etc/pki/taskd/directorio.

2. Copie los siguientes archivos en su directorio de usuarios, cambie la propiedad y los permisos. Sustituya joeqpublic a continuación con su directorio de nombre de usuario real.

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

3. Cree un archivo zip de los certificados y la clave.

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

4. Use scp(línea de comando) o WinSCP (interfaz gráfica de usuario para SCP) para descargar el certificates.ziparchivo de su instancia de CentOS a su dispositivo cliente (computadora / computadora portátil / teléfono inteligente).

5. Descarte los privilegios de root y ejecute el resto de sus comandos como su usuario habitual.

   exit
   

   TaskServer (taskd) ahora está configurado y listo para que los clientes TaskWarrior (task) se conecten.

Paso 6: Crea tu primer grupo y usuario de TaskWarrior

1. Para crear, eliminar, modificar y sincronizar sus tareas, necesitará una cuenta de usuario. Sin embargo, antes de poder agregar usuarios, primero deberá crear un grupo organizativo. Ejecute el siguiente comando para crear su primer grupo. Reemplace GRUPO con un nombre fácilmente reconocible.

2. ¡IMPORTANTE! El taskdcomando para crear grupos / usuarios debe ejecutarse como taskdusuario. Al ejecutarse como usuario raíz, se crearán directorios y archivos propiedad del usuario raíz, /var/lib/taskd/orgslo que evitará que los clientes de TaskWarrior (tarea) puedan acceder o modificar cualquier cosa en el grupo al que han sido asignados. El acceso será denegado.

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

3. Ahora que ha creado su primer grupo, creemos su primer usuario. Ejecute el siguiente comando para crear un usuario asignado al grupo creado en el paso 1. Copie y pegue la clave de usuario, el usuario y el grupo generados en un archivo de texto. Repita el proceso para agregar usuarios adicionales.

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

Paso 7: Instalar clientes TaskWarrior

Windows 10 (compilación posterior a 1607+)

Para usar TaskWarrior (tarea) en Windows 10, debe instalar el Subsistema de Windows para Linux desde la Tienda Windows.

1. Para instalar WSL, se requiere un indicador de Powershell elevado. Presione la tecla de ventana y escriba powershell . Haga clic derecho en Windows Powershell en la parte superior de los resultados y seleccione " Ejecutar como administrador ". Cuando se le solicite Control de cuentas de usuario, haga clic en Sí . Copie y pegue el texto que se encuentra a continuación en las ventanas de Powershell. Cuando WSL termine de instalar, presione la tecla Y para reiniciar Windows.

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

2. Después de reiniciar, abra un símbolo del sistema y escriba el siguiente comando bash . Esto instalará Ubuntu en Windows. Pulse la tecla Y . Ahora se descargará y extraerá. Elige un nombre de usuario y contraseña.

   bash
   

3. Ahora es el momento de instalar TaskWarrior (tarea). Escriba el siguiente comando dentro de la consola.

   sudo apt-get install task -y
   

4. Escriba exit dos veces para salir del terminal bash y el símbolo del sistema de Windows.

5. Haz clic en el botón del menú Inicio. Escribe ubuntu . Haga clic derecho en Bash en Ubuntu en Windows . Seleccione Anclar a la barra de tareas . Esto proporciona comodidad para acceder rápidamente a bash para acceder a TaskWarrior (tarea).

6. Haga clic en el icono de Ubuntu que acaba de crear en la barra de tareas. Esto abrirá una ventana de terminal que ejecuta Bash. Escriba el siguiente comando a continuación para crear el directorio de datos TaskWarrior (tarea) ( ~/.task/) y el archivo de configuración ( .taskrc).

   task version
   yes
   

7. certificates.zipDebe mover el archivo que guardó anteriormente durante la configuración del TaskServer al ~/.taskd/directorio dentro de su directorio de usuario. Para extraer los archivos del archivo zip, instale unzipprimero el programa. Copie y pegue los siguientes comandos sustituyendo la ubicación real de su copia de certificates.zip.

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

8. Escriba los siguientes comandos para configurar TaskWarrior (tarea) para conectarse con TaskServer (taskd). Reemplace NOMBRE con lo que ha nombrado su certificado y clave, GRUPO con el grupo que ha creado, Joe Q. Público con el nombre de usuario que ha creado y XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la clave asignada cuando su usuario fue creado en el servidor 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. Ahora es el momento de sincronizar TaskWarrior (tarea) con TaskServer (taskd). Ejecute el siguiente comando para inicializar la base de datos.

   task sync init
   

   La sincronización entre su cliente TaskWarrior (tarea) y el TaskServer (taskd) ahora está configurado en la plataforma Windows 10.

Androide

Para usar TaskWarrior (tarea) en Android, debe instalar TaskWarrior para Android desde Google Play Store.

1. Instale la aplicación TaskWarrior (tarea) para Android en Google Play Store.

2. Abra la aplicación TaskWarrior (tarea) para Android.

3. La aplicación le pedirá que cree una cuenta con un nombre de cuenta deseado . Ingrese el nombre que eligió cuando creó un nombre de usuario para un usuario de TaskServer (taskd).

4. Deje la carpeta de datos con la configuración predeterminada de << Crear nuevo >> y toque el botón Aceptar . Use una aplicación de administrador de archivos para crear una carpeta en su raíz de almacenamiento (por ejemplo:) /storage/emulate/0/Certs. Enviar la aplicación a un segundo plano.

5. Copie el certificates.ziparchivo que creó anteriormente y extraiga su contenido en el directorio creado en el paso 4.

6. En primer plano, la aplicación "TaskWarrior (tarea) para Android" y toque el menú en la esquina superior izquierda de la aplicación para abrirla.

7. Desplácese hasta la parte inferior del menú y toque la opción Configuración .

8. Esto abrirá un sencillo editor de texto integrado de la aplicación TaskWarrior para Android.

9. Ingrese las siguientes opciones para configurar la sincronización con su TaskServer (taskd). Reemplace las variables taskd.ca/ taskd.certificate/ taskd.key` con la (s) ruta (s) real del directorio ca / ​​certificado / clave, NOMBRE con lo que denominó su certificado y clave, GRUPO con el grupo que creó, Joe Q. Público con el nombre de usuario que creó y XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la clave asignada cuando creó su usuario en el servidor 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. Toque el icono del disquete para guardar su configuración.

La sincronización entre su cliente TaskWarrior (tarea) y el TaskServer (taskd) ahora está configurado en la plataforma Android.

Linux

1. Consulte la sección de distribución de TaskWarrior (tarea) para instalar su distribución particular de Linux .

2. Abre una ventana de terminal. Escriba el siguiente comando a continuación para crear el directorio de datos TaskWarrior (tarea) ( ~/.task/) y el archivo de configuración ( .taskrc).

   task version
   yes
   

3. certificates.zipDebe mover el archivo que guardó anteriormente en la configuración del TaskServer al ~/.taskd/directorio dentro de su directorio de usuario. Para extraer los archivos del archivo zip, instale unzipprimero el programa para su distribución particular. Copie y pegue los siguientes comandos a continuación, sustituyendo la ubicación real de su copia de certificates.zip.

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

4. Escriba los siguientes comandos para configurar TaskWarrior (tarea) para conectarse con TaskServer (taskd). Reemplace NOMBRE con lo que ha nombrado su certificado y clave, GRUPO con el grupo que ha creado, Joe Q. Público con el nombre de usuario que ha creado y XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX con la clave asignada cuando su usuario fue creado en el servidor 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. Ahora es el momento de sincronizar TaskWarrior (tarea) con TaskServer (taskd). Ejecute el siguiente comando para inicializar la base de datos.

   task sync init
   

Anexo: Si ejecuta Gnome Shell, hay una extensión llamada TaskWhisper que se integra con TaskWarrior (tarea).

La sincronización entre su cliente TaskWarrior (tarea) y el TaskServer (taskd) ahora está configurada en su distribución de Linux favorita.