Como Instalar o Wiki.js - Software Wiki baseado em NodeJS no Debian 9

Wiki.js é um aplicativo wiki moderno, poderoso e de código aberto baseado em Node.js, Git e Markdown. O Wiki.js é executado no motor Node.js extremamente rápido e é otimizado para conservar recursos da CPU. Algumas das características do Wiki.js que valem a pena mencionar são:

• Edição em Markdown, suportada pelo Git
• Leve, mas extremamente poderoso
• Lindamente projetado para a web moderna
• Controle de Acesso Integrado
• Gerenciamento Intuitivo de Ativos
• Motor de busca embutido

Neste tutorial, vamos guiá-lo pelo processo de instalação da versão 1 do Wiki.js em um sistema operacional Debian 9, usando o NGINX como servidor proxy reverso, MongoDB como servidor de banco de dados, PM2 como gerenciador de processos e, opcionalmente, você pode proteger a camada de transporte usando o cliente acme.sh e a autoridade certificadora Let’s Encrypt para adicionar suporte a SSL.

Requisitos

Os requisitos para executar o Wiki.js são os seguintes:

• Node.js 6.11.1 a 10.x é necessário.
• Versão do MongoDB 3.2 ou posterior.
• Versão do Git 2.7.4 ou posterior.
• Software de servidor web como NGINX, Apache, Caddy, H2O…
• Um repositório Git vazio (opcional).
• Mínimo de 512MB de RAM. 1GB de RAM recomendado.
• Cerca de 300MB de espaço em disco.
• Nome de domínio com registros DNS A/AAAA configurados.

Pré-requisitos

• Um sistema operacional Debian 9.
• Um usuário não-root com privilégios sudo.

Passos Iniciais

Verifique a versão do seu sistema Debian:

lsb_release -ds  
# Debian GNU/Linux 9.8 (stretch)

Configure o fuso horário:

dpkg-reconfigure tzdata

Atualize os pacotes do seu sistema operacional (software). Este é um primeiro passo importante porque garante que você tenha as últimas atualizações e correções de segurança para os pacotes de software padrão do seu sistema operacional:

apt update && apt upgrade -y

Instale alguns pacotes essenciais que são necessários para a administração básica do sistema operacional Debian:

apt install -y curl wget vim git unzip socat sudo bash-completion apt-transport-https build-essential dirmngr

Passo 1 - Instalar Node.js e npm

O Wiki.js é construído sobre o Node.js. Vamos instalar a versão recomendada mais recente para o Wiki.js, que é a versão 10 no momento da redação deste texto. No Linux, você tem algumas opções de instalação do Node.js: Binaries do Linux (x86/x64), Código Fonte ou via Gerenciadores de Pacotes. Vamos usar uma opção de Gerenciamento de Pacotes que torna a instalação e atualização do Node.js muito fácil.

Baixe e instale a versão recomendada mais recente do Node.js do repositório NodeSource:

`curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -  
sudo apt install -y nodejs `

NOTA: npm é distribuído com o Node.js - o que significa que quando você baixa o Node.js, você automaticamente obtém o npm instalado em seu sistema.

Verifique a versão do Node.js e npm:

`node -v && npm -v  
# v10.15.1  
# 6.4.1  
`

Npm é um projeto separado do Node.js e tende a ser atualizado com mais frequência. Como resultado, mesmo que você tenha acabado de baixar o Node.js (e, portanto, o npm), provavelmente você precisará atualizar seu npm. Felizmente, o npm sabe como se atualizar! Para atualizar seu npm, digite isto no seu terminal:

sudo npm install -g npm@latest

Este comando atualizará o npm para a versão estável mais recente.

Verifique novamente a versão do npm com:

npm -v  
# 6.8.0  

E deve retornar o número da versão mais recente.

Passo 2 - Instalar o banco de dados MongoDB

O Wiki.js precisa de um banco de dados para armazenar seus dados, e a versão estável atual do Wiki.js suporta apenas o mecanismo de banco de dados MongoDB. De acordo com isso, precisaremos instalar o banco de dados MongoDB.

Baixe e instale o banco de dados MongoDB:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 9DA31620334BD75D9DCB49F368818C72E52529D4  
echo "deb http://repo.mongodb.org/apt/debian stretch/mongodb-org/4.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.0.list  
sudo apt-get update  
sudo apt-get install -y mongodb-org  

Verifique a versão do MongoDB:

mongo --version | head -n 1 && mongod --version | head -n 1  

Inicie e habilite (configure para iniciar na reinicialização) o serviço MongoDB, se ainda não estiver iniciado e habilitado:

sudo systemctl start mongod.service  
sudo systemctl enable mongod.service  

Passo 3 - Instalar o cliente acme.sh e obter o certificado Let’s Encrypt (opcional)

Proteger seu site com HTTPS não é necessário, mas é uma boa prática proteger o tráfego do seu site. Para obter um certificado SSL do Let’s Encrypt, usaremos o cliente acme.sh. Acme.sh é um software de shell UNIX puro para obter certificados SSL do Let’s Encrypt com zero dependências.

Baixe e instale o acme.sh:

sudo su - root  
git clone https://github.com/Neilpang/acme.sh.git  
cd acme.sh  
./acme.sh --install --accountemail [email protected]  
source ~/.bashrc  
cd ~

Verifique a versão do acme.sh:

acme.sh --version  
# v2.8.1

Obtenha certificados RSA e ECC/ECDSA para seu domínio/nome do host:

# RSA 2048  
acme.sh --issue --standalone -d example.com --keylength 2048  
# ECDSA  
acme.sh --issue --standalone -d example.com --keylength ec-256

Se você quiser certificados falsos para teste, pode adicionar a flag --staging aos comandos acima.

Para listar seus certificados emitidos, você pode executar:

acme.sh --list

Crie pastas para armazenar seus certificados. Usaremos /etc/letsencrypt, mas pode ser qualquer coisa que você preferir para armazenar certificados SSL.

mkdir -p /etc/letsencrypt/example.com  
mkdir -p /etc/letsencrypt/example.com_ecc

Instale/copie os certificados para o diretório /etc/letsencrypt.

# RSA  
acme.sh --install-cert -d example.com \   
        --cert-file /etc/letsencrypt/example.com/cert.pem \  
        --key-file /etc/letsencrypt/example.com/private.key \  
        --fullchain-file /etc/letsencrypt/example.com/fullchain.pem \  
        --reloadcmd "sudo systemctl reload nginx.service"  
  
# ECC/ECDSA  
acme.sh --install-cert -d example.com --ecc \  
        --cert-file /etc/letsencrypt/example.com_ecc/cert.pem \  
        --key-file /etc/letsencrypt/example.com_ecc/private.key \  
        --fullchain-file /etc/letsencrypt/example.com_ecc/fullchain.pem \  
        --reloadcmd "sudo systemctl reload nginx.service"

Após executar os comandos acima, seus certificados e chaves estarão em:

• Para RSA: diretório /etc/letsencrypt /example.com.
• Para ECC/ECDSA: diretório /etc/letsencrypt /example.com_ecc.

Todos os certificados serão renovados automaticamente a cada 60 dias.

Após obter os certificados, saia do usuário root e volte ao usuário normal com sudo:

exit

Passo 4 - Instalar e configurar o NGINX

O Wiki.js (ou qualquer aplicativo HTTP Node.js) pode ser executado sem um servidor web real (como NGINX ou Apache). No entanto, é altamente recomendável colocar um servidor web padrão na frente do Wiki.js. Isso garante que você possa usar recursos como SSL, vários sites, cache, etc. Usaremos o NGINX neste tutorial, mas qualquer outro servidor funcionará, você só precisa configurá-lo corretamente.

Baixe e instale o NGINX do repositório oficial do NGINX emitindo os seguintes comandos:

wget https://nginx.org/keys/nginx_signing.key  
sudo apt-key add nginx_signing.key  
rm nginx_signing.key  
sudo -s  
printf "deb https://nginx.org/packages/mainline/debian/ $(lsb_release -sc) nginx\ndeb-src https://nginx.org/packages/mainline/debian/ $(lsb_release -sc) nginx\n" >> /etc/apt/sources.list.d/nginx_mainline.list  
exit  
sudo apt update  
sudo apt install -y nginx

Verifique a versão do NGINX:

sudo nginx -v  
# nginx version: nginx/1.15.8

Habilite e inicie o serviço NGINX:

sudo systemctl enable nginx.service  
sudo systemctl start nginx.service

Execute sudo vim /etc/nginx/conf.d/wiki.js.conf e configure o NGINX como um proxy reverso HTTPS.

server {
      
    listen [::]:443 ssl http2;  
    listen 443 ssl http2;
    listen [::]:80;
    listen 80;
    
    server_name example.com;

    charset utf-8;
    client_max_body_size 50M;  
    
    ssl_certificate /etc/letsencrypt/example.com/fullchain.pem;  
    ssl_certificate_key /etc/letsencrypt/example.com/private.key;  
    ssl_certificate /etc/letsencrypt/example.com_ecc/fullchain.pem;  
    ssl_certificate_key /etc/letsencrypt/example.com_ecc/private.key;
    
    location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_next_upstream error timeout http_502 http_503 http_504;
    }
    
}

A única coisa que você precisa mudar na configuração acima é a diretiva server_name, e potencialmente a diretiva proxy_pass se você decidir configurar algo diferente da porta 3000. O Wiki.js usa a porta 3000 por padrão.

Verifique a configuração do NGINX:

sudo nginx -t  

Finalmente, para que as alterações tenham efeito, precisamos recarregar o NGINX:

sudo systemctl reload nginx.service

Passo 5 - Instalar e configurar o Wiki.js

Crie um diretório raiz de documentos onde o Wiki.js deve residir:

sudo mkdir -p /var/www/wiki.js

Navegue até o diretório raiz de documentos:

cd /var/www/wiki.js

Altere a propriedade do diretório /var/www/wiki.js para seu_usuario:

sudo chown -R [seu_usuario]:[seu_usuario] /var/www/wiki.js

NOTA: Substitua seu_usuario no comando acima pelo seu usuário não-root que você deve ter criado como pré-requisito para este tutorial .

A partir do diretório /var/www/wiki.js, execute o seguinte comando para buscar e instalar a aplicação Wiki.js mais recente:

curl -sSo- https://wiki.js.org/install.sh | bash

Uma vez que a instalação esteja concluída, você pode executar o seguinte comando para visualizar a versão atualmente instalada do Wiki.js:

node wiki --version  
# 1.0.117

Uma vez que a instalação esteja concluída, você será solicitado a iniciar o assistente de configuração.

Então, inicie o assistente de configuração executando:

node wiki configure

Usando seu navegador web, navegue até http://example.com e siga as instruções na tela. Todas as configurações inseridas durante o assistente de configuração são salvas no arquivo config.yml. O assistente de configuração iniciará automaticamente o Wiki.js para você.

Primeiro, você verá uma mensagem de boas-vindas. Clique no botão “ Iniciar “:

A próxima página “Verificação do Sistema” aparecerá. Se todos os requisitos forem atendidos, clique no botão “ Continuar “:

Insira informações gerais sobre seu wiki e clique no botão “ Continuar “:

Leia o aviso “Considerações Importantes” e clique em “ Continuar “ para o próximo passo:

Em seguida, conecte-se ao banco de dados e continue:

Você deve ver uma mensagem de que o Wiki.js foi conectado com sucesso ao banco de dados. Clique no botão “ Continuar “:

Defina os caminhos e continue:

Configure o repositório Git remoto se desejar ou pule esta etapa. Esta etapa é opcional, mas altamente recomendada:

Em seguida, clique no botão “Continuar”:

Crie uma conta de administrador e clique no botão “ Continuar “:

E finalmente, inicie o Wiki.js:

Aguarde cerca de 30 segundos e você deve ser redirecionado para a página inicial do Wiki.js:

A instalação está concluída. Você deve ver a página de boas-vindas do wiki:

Passo 6 - Configurar o Gerenciador de Processos PM2

Por padrão, o Wiki.js não será iniciado automaticamente após uma reinicialização do sistema. Para que ele inicie na inicialização, precisamos configurar o gerenciador de processos PM2. O PM2 vem incluído com o Wiki.js como um módulo npm local, então não precisamos instalar o PM2 globalmente.

Diga ao PM2 para se configurar como um serviço de inicialização executando:

/var/www/wiki.js/node_modules/pm2/bin/pm2 startup

Finalmente, salve a configuração atual do PM2 executando o comando:

/var/www/wiki.js/node_modules/pm2/bin/pm2 save

Seu Wiki.js agora é executado como um processo em segundo plano, usando o PM2 como seu gerenciador de processos.

Links

• https://wiki.js.org/
• https://github.com/Requarks/wiki-v1
• https://github.com/Requarks/wiki