Instalar o TaskServer (taskd) no CentOS 7

TaskWarrior é uma ferramenta de gerenciamento de tempo de código aberto que é uma melhoria no aplicativo Todo.txt e seus clones. Devido ao fato de que a pessoa comum usa vários dispositivos / plataformas em sua programação diária, é fundamental ter um repositório centralizado onde os dados podem ser acessados ​​e atualizados a partir de qualquer dispositivo. Este tutorial se concentrará em configurar o servidor, chamado TaskServer (taskd), e o cliente, chamado TaskWarrior (task), permitindo que vários dispositivos clientes acessem e troquem dados com segurança.

Possui os seguintes recursos:

• Tarefas ilimitadas
• Priorização de tarefas
• Filtragem de pesquisa
• Marcação
• Sincronização automática
• Backup automático
• Controle total e privacidade
• Comunicação criptografada

Pré-requisitos

• Uma instância do servidor CentOS 7 x64.
• Um usuário sudo .
• Nome de domínio apontado para uma instância do Vultr (taskd.example.com)

Etapa 1: atualizar o sistema

Efetue login como seu usuário sudo para instalar o Repositório EPEL e atualize o sistema da seguinte maneira:

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

Etapa 2: Instalar o RPM Build e as ferramentas para criação

O repositório EPEL não contém um RPM para o TaskServer (taskd), portanto, temos que construí-lo da fonte em um pacote RPM.

1. Instale as ferramentas GCC, Make, RPM Build, desenvolvimento e assinatura.

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

2. Crie um diretório GnuPG que conterá os arquivos GPG necessários para assinar nosso RPM.

   mkdir .gnupg
   

3. Ao criar uma chave, exigimos que a entropia no sistema a randomize adequadamente. O rngddaemon gera a entropia necessária a partir de /dev/urandom. Então, vamos instalar isso agora.

   yum install rngd -y
   

4. Inicie o rngddaemon para gerar entropia. A opção -r aponta para em /dev/urandomvez do padrão /dev/hwrng.

   sudo rngd -r /dev/urandom
   

5. Gere uma chave. A opção --gen-key diz ao gpg para gerar um novo par de chaves.

   gpg --gen-key
   

6. Para a opção " Selecione o tipo de chave que deseja: ", selecione " (1) RSA e RSA (padrão) " para o tipo de chave digitando 1 e pressionando a tecla Return / Enter .

7. Para a opção " Qual o tamanho da chave que você deseja? (2048) ", escolha o padrão pressionando a tecla Return / Enter .

8. Para a opção " Especifique por quanto tempo a chave deve ser válida. ", Escolha o padrão pressionando a tecla Return / Enter .

9. Para a opção " Isso está correto? (S / N) ", digite y e pressione a tecla Retornar / Enter .

10. Em " Nome real: ", digite o nome de sua escolha e pressione a tecla Return / Enter .

11. Em " Endereço de email: ", insira um endereço de email de sua escolha e pressione a tecla Return / Enter .

12. A seção Comentário: pode ser deixada em branco, se você escolher.

13. Faça as alterações necessárias se você não inserir suas informações corretamente. Se você estiver satisfeito com as informações de USER-ID exibidas, digite O (letra maiúscula O, não zero) e pressione a tecla Return / Enter .

14. O GnuPG agora solicitará que você crie e verifique uma senha para o seu par de chaves.

15. Depois de inserir suas senhas, seu par de chaves GnuPG será criado no .gnupgdiretório em seu diretório de usuário.

16. Execute este comando para exibir o conteúdo do .gnupgdiretório. Ele deve conter o seguinte diretório private-keys-v1.de arquivos pubring.gpg, pubring.gpg~, random_seed, secring.gpg, S.gpg-agent, trustdb.gpg.

    ls -la .gnupg
    

17. Exporte o par de chaves criado. A opção --export instrui o GnuPG a exportar o par de chaves. A opção -a instrui o GnuPG a emitir o par de chaves no formato de armadura ascii . Substitua " Joe Q. Public " pelo nome digitado ao criar o par de chaves na etapa 10 acima. Substitua " jqpublic " pelo texto que você escolher.

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

18. Importe o par de chaves no keystore do RPM. Substitua " jqpublic " pelo texto que você escolheu na etapa 17.

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

19. Verifique se o par de chaves foi adicionado ao keystore do RPM. A opção --q gpg-pubkey consulta o keystore do RPM GnuPG. O % {name} -% {version} -% {release} ->% {summary} \ n exibe o resultado em um formato legível por humanos.

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

20. Ao criar um .rpmmacros file, o RPM pode ser personalizado para executar comportamentos atribuídos (exemplo: facilitar a assinatura automática de RPMs). Use o nanoprograma para criar o arquivo.

    nano .rpmmacros
    

21. Em seguida, adicione o seguinte texto abaixo no .rpmmacrosarquivo.

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

22. Salve o documento digitando as seguintes combinações de teclado. Os CTRL + X Chaves. Então, a tecla S. Finalmente, a tecla Return / Enter .

23. Este comando abaixo configurará seu ambiente de construção do RPM. Isso anexará macros adicionais ao .rpmmacrosarquivo que você criou na etapa 20 e criará os diretórios necessários para criar e armazenar RPMs.

    rpmdev-setuptree
    

24. Execute este comando para exibir o conteúdo do diretório rpmbuild. Ele deve conter os seguintes diretórios FONTES , RPMS , BUILD , SRPMS e SPECS .

    find rpmbuild
    

25. Faça o download do código-fonte do TaskServer (taskd) para o rpmbuild/SOURCESdiretório

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

26. Mate o rgndprocesso em execução .

    sudo kill -9 rngd
    

Etapa 3: Criar RPM do TaskServer (taskd) a partir da origem

1. Para criar um novo RPM a partir da origem, um arquivo SPEC do TaskServer (taskd) deve ser criado.

   nano rpmbuild/SPECS/taskd.spec
   

2. Adicione o seguinte texto abaixo ao taskd.specarquivo.

   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. O RPM também requer três arquivos adicionais que devem ser criados no rpmbuild/SOURCESdiretório. Use o nanoprograma para criar o taskd-configarquivo.

   nano rpmbuild/SOURCES/taskd-config
   

4. Adicione o seguinte texto abaixo ao taskd-configarquivo.

   # 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 o nanoprograma para criar o taskd.servicearquivo.

   nano rpmbuild/SOURCES/taskd.service
   

6. Adicione o seguinte texto abaixo ao taskd.servicearquivo.

   [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 o nanoprograma para criar o taskd.xmlarquivo.

   nano rpmbuild/SOURCES/taskd.xml
   

8. Adicione o seguinte texto abaixo ao taskd.xmlarquivo.

   <?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 o RPM TaskServer (taskd), três pacotes são necessários para a construção. Execute o comando abaixo para instalar esses pacotes.

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

10. Agora é hora de construir a partir da fonte e criar um RPM para TaskServer (taskd). Execute os comandos abaixo para começar. Em uma instância 1x CPU Vultr, deve demorar menos de um minuto para criar os RPMs. Digite a senha do GnuPG criada na etapa 14 para assinar o RPM quando solicitado.

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

11. Instale o RPM do TaskServer (taskd).

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

Etapa 4: Configurar o TaskServer (tarefa)

1. Para que o TaskServer (taskd) se comunique e sincronize com os clientes TaskWarrior (task), você precisará usar os scripts de geração encontrados em /etc/pki/taskd/para gerar certificados / chaves de servidor e cliente. Eleve ao usuário root usando o comando abaixo e altere o diretório para /etc/pki/taskd.

   sudo su -
   cd /etc/pki/taskd/
   

2. Use o nanoprograma para criar um varsarquivo para gerar uma CA raiz autoassinada.

   nano vars
   

   Adicione o seguinte texto abaixo no arquivo vars. Altere ORGANIZAÇÃO , CN , PAÍS , ESTADO e LOCALIDADE para sua satisfação.

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

3. Gere a CA raiz autoassinada, certificado, chave do servidor e lista de revogação do servidor (opcional).

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

   Estes comandos irá criar os seguintes arquivos ( ca.cert.pem, ca.key.pem, server.cert.pem, server.key.peme server.crl.pem) dentro do /etc/pki/taskd/diretório. Para que o TaskServer (taskd) seja iniciado, a propriedade e as permissões dos certificados e chaves gerados na etapa # 37 devem ser modificadas para permitir que o TaskServer (taskd) os acesse. Execute os comandos abaixo para alterá-los.

   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. Ative e inicie o daemon TaskServer (taskd).

   systemctl enable taskd
   systemctl start taskd
   

5. Abra a porta no firewall TaskServer (taskd) executado.

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

   O TaskServer (taskd) agora está instalado e configurado na sua instância do CentOS 7.

Etapa 5: Configurar o certificado e a chave do cliente TaskWarrior

1. Você deve criar certificados e chave de cliente para criptografar as comunicações entre o TaskServer (taskd) e o TaskWarrior (tarefa). Execute o comando abaixo para gerar um certificado e uma chave do cliente. Substitua NAMEpor um nome que você possa reconhecer facilmente para seu cliente.

   generate.client NAME
   

   Este comando criará os seguintes arquivos ( NAME.cert.pem, NAME.key.pem) dentro do /etc/pki/taskd/diretório.

2. Copie os seguintes arquivos para o diretório do usuário, altere a propriedade e as permissões. Substitua joeqpublic abaixo por seu diretório de nome de usuário 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. Crie um arquivo zip dos certificados e da chave.

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

4. Use scp(linha de comando) ou WinSCP (interface gráfica do usuário para SCP) para baixar o certificates.ziparquivo da instância do CentOS para o dispositivo cliente (computador / laptop / smartphone).

5. Abandone os privilégios de root e execute o restante de seus comandos como usuário regular.

   exit
   

   O TaskServer (taskd) agora está configurado e pronto para os clientes TaskWarrior (task) se conectarem.

Etapa 6: Crie seu primeiro grupo e usuário do TaskWarrior

1. Para criar, excluir, modificar e sincronizar suas tarefas, você precisará de uma conta de usuário. No entanto, antes de adicionar usuários, você precisará criar um grupo organizacional. Execute o comando abaixo para criar seu primeiro grupo. Substitua GROUP por um nome facilmente reconhecível.

2. IMPORTANTE! O taskdcomando para criar grupos / usuários deve ser executado como o taskdusuário. A execução como usuário raiz criará diretórios e arquivos pertencentes ao usuário raiz, nos /var/lib/taskd/orgsquais evitará que os clientes TaskWarrior (tarefa) possam acessar ou modificar qualquer coisa no grupo ao qual foram atribuídos. O acesso será negado.

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

3. Agora que você criou seu primeiro grupo, vamos criar seu primeiro usuário. Execute o comando abaixo para criar um usuário atribuído ao grupo criado na etapa 1. Copie e cole a chave do usuário, usuário e grupo gerados em um arquivo de texto. Repita o processo para adicionar usuários adicionais.

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

Etapa 7: Instalar clientes TaskWarrior

Windows 10 (versão posterior a 1607 ou superior)

Para usar o TaskWarrior (tarefa) no Windows 10, é necessário instalar o Windows Subsystem For Linux a partir da Windows Store.

1. Para instalar o WSL, é necessário um prompt elevado do Powershell. Pressione a tecla Janela e digite powershell . Clique com o botão direito do mouse no Windows Powershell na parte superior dos resultados e selecione " Executar como administrador ". No prompt Controle de Conta de Usuário, clique em Sim . Copie e cole o texto encontrado abaixo nas janelas do Powershell. Quando o WSL concluir a instalação, pressione a tecla Y para reiniciar o Windows.

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

2. Após a reinicialização, abra um prompt de comando e digite o seguinte comando bash . Isso instalará o Ubuntu no Windows. Pressione a tecla Y . Agora ele será baixado e extraído. Escolha um nome de usuário e senha.

   bash
   

3. Agora é hora de instalar o TaskWarrior (tarefa). Digite o seguinte comando dentro do console.

   sudo apt-get install task -y
   

4. Digite exit duas vezes para sair do terminal bash e do prompt de comando do Windows.

5. Clique no botão Menu Iniciar. Digite ubuntu . Clique com o botão direito do mouse em Bash no Ubuntu no Windows . Selecione Fixar na barra de tarefas . Isso fornece comodidade para acessar rapidamente o bash para acessar o TaskWarrior (tarefa).

6. Clique no ícone do Ubuntu que você acabou de criar na barra de tarefas. Isso abrirá uma janela de terminal executando o Bash. Digite o seguinte comando abaixo para criar o diretório de dados TaskWarrior (task) ( ~/.task/) e o arquivo de configuração ( .taskrc).

   task version
   yes
   

7. Você precisa mover o certificates.ziparquivo que você salvou anteriormente durante a instalação do TaskServer para o ~/.taskd/diretório dentro do diretório do usuário. Para extrair os arquivos do arquivo zip, instale o unzipprograma primeiro. Copie e cole os seguintes comandos abaixo, substituindo o local real da sua cópia certificates.zip.

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

8. Digite os seguintes comandos para configurar o TaskWarrior (tarefa) para conectar-se ao TaskServer (taskd). Substitua NAME pelo nome do seu certificado e chave, GROUP pelo grupo que você criou, Joe Q. Público pelo nome de usuário que você criou e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX pela chave atribuída quando o usuário foi criado no 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. Agora é hora de sincronizar o TaskWarrior (tarefa) com o TaskServer (taskd). Execute o comando abaixo para inicializar o banco de dados.

   task sync init
   

   A sincronização entre o cliente TaskWarrior (task) e o TaskServer (taskd) agora está configurada na plataforma Windows 10.

Android

Para usar o TaskWarrior (task) no Android, você precisa instalar o TaskWarrior For Android na Google Play Store.

1. Instale o aplicativo TaskWarrior (task) For Android na Play Store do Google.

2. Abra o aplicativo TaskWarrior (tarefa) para Android.

3. Você será solicitado pelo aplicativo a criar uma conta com um nome de conta desejado . Digite o nome que você escolheu quando criou um nome de usuário para um usuário do TaskServer (taskd).

4. Deixe a pasta de dados na configuração padrão << Criar novo >> e toque no botão OK . Use um aplicativo gerenciador de arquivos para criar uma pasta na raiz do armazenamento (por exemplo /storage/emulate/0/Certs:). Envie o aplicativo para o segundo plano.

5. Copie o certificates.ziparquivo que você criou anteriormente e extraia seu conteúdo no diretório criado na etapa 4.

6. Primeiro, selecione o aplicativo "TaskWarrior (tarefa) para Android" e toque no menu no canto superior esquerdo do aplicativo para abri-lo.

7. Role até a parte inferior do menu e toque na opção Configurações .

8. Isso abrirá um editor de texto simples do aplicativo TaskWarrior For Android.

9. Digite as seguintes opções para configurar a sincronização com o TaskServer (taskd). Substitua as variáveis taskd.ca/ taskd.certificate/ taskd.key` pelos caminhos reais do diretório ca / ​​certificate / key, NAME pelo nome do seu certificado e chave, GROUP pelo grupo que você criou, Joe Q. Public pelo nome de usuário que você criou e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX com a chave atribuída quando você criou seu usuário no 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 no ícone do disquete para salvar suas configurações.

A sincronização entre o cliente TaskWarrior (task) e o TaskServer (taskd) agora está configurada na plataforma Android.

Linux

1. Consulte a seção de distribuição TaskWarrior (tarefa) para instalar sua distribuição Linux específica .

2. Abra uma janela do terminal. Digite o seguinte comando abaixo para criar o diretório de dados TaskWarrior (task) ( ~/.task/) e o arquivo de configuração ( .taskrc).

   task version
   yes
   

3. Você precisa mover o certificates.ziparquivo que você salvou anteriormente na configuração do TaskServer para o ~/.taskd/diretório dentro do diretório do usuário. Para extrair os arquivos do arquivo zip, instale o unzipprograma primeiro para sua distribuição específica. Copie e cole os seguintes comandos abaixo, substituindo o local real da sua cópia de certificates.zip.

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

4. Digite os seguintes comandos para configurar o TaskWarrior (tarefa) para conectar-se ao TaskServer (taskd). Substitua NAME pelo nome do seu certificado e chave, GROUP pelo grupo que você criou, Joe Q. Público pelo nome de usuário que você criou e XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX pela chave atribuída quando o usuário foi criado no 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. Agora é hora de sincronizar o TaskWarrior (tarefa) com o TaskServer (taskd). Execute o comando abaixo para inicializar o banco de dados.

   task sync init
   

Adendo: Se você executar o Gnome Shell, há uma extensão chamada TaskWhisper que se integra ao TaskWarrior (tarefa).

A sincronização entre o cliente TaskWarrior (task) e o TaskServer (taskd) agora está configurada na sua distribuição Linux favorita.