Pular para o conteúdo principal

Lab 5.8 - Instalar Wiki.js no Ubuntu 24.04 LTS com PostgreSQL

Objetivos​

Ao final deste lab, você será capaz de:

  • Instalar Git e Node.js no Ubuntu 24.04
  • Instalar e configurar PostgreSQL
  • Baixar e configurar Wiki.js com PostgreSQL
  • Criar um serviço systemd para o Wiki.js
  • Gerenciar serviços Node.js e systemd
  • Explorar o PostgreSQL via terminal
  • Resolver problemas comuns

Pré-requisitos​

  • Ubuntu 24.04 LTS instalado
  • Acesso sudo
  • Conexão com a Internet
  • Pelo menos 2 GB de RAM disponível
  • Pelo menos 5 GB de espaço livre em disco

Parte 1: Instalação do Git​

sudo apt update
sudo apt install git -y
git --version

Parte 2: Instalação do Node.js (LTS)​

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs
node -v && npm -v

Parte 3: Instalação e Configuração do PostgreSQL​

Instalação do PostgreSQL​

sudo apt install postgresql postgresql-contrib -y
sudo systemctl start postgresql
sudo systemctl enable postgresql
sudo systemctl status postgresql

Criação do banco de dados e do usuário​

sudo -u postgres psql

No prompt do PostgreSQL:

CREATE DATABASE wikidb;
CREATE USER wikidb_user WITH PASSWORD 'StrongPassword123!';
GRANT ALL PRIVILEGES ON DATABASE wikidb TO wikidb_user;
\q

Nota: Substitua StrongPassword123! por uma senha segura de sua escolha.

Parte 4: Criação de um Usuário de Sistema para o Wiki.js​

# Criar um usuário de sistema
sudo adduser --system --group wikijs

# Criar o diretório de instalação
sudo mkdir -p /var/www/wikijs

# Verificar a criação
ls -l /var/www

# Definir o proprietário
sudo chown -R wikijs:wikijs /var/www/wikijs

# Verificar as permissões
ls -l /var/www

# Permitir login com bash
sudo usermod -s /bin/bash wikijs

Parte 5: Instalação do Wiki.js​

Adicionar wikijs aos sudoers e definir uma senha​

# Definir uma senha para wikijs
sudo passwd wikijs
# Digite a senha (por exemplo: wikijs)

# Adicionar wikijs ao grupo sudo
sudo usermod -aG sudo wikijs

# Verificar
groups wikijs
# Deve exibir: wikijs : wikijs sudo

Baixar e instalar o Wiki.js​

# Conectar como wikijs
sudo su - wikijs

# Ir para o diretório de instalação
cd /var/www/wikijs

# Baixar o Wiki.js
wget https://github.com/Requarks/wiki/releases/latest/download/wiki-js.tar.gz

# Extrair o arquivo
tar xzf wiki-js.tar.gz

# Remover o arquivo
rm wiki-js.tar.gz

# Copiar o arquivo de configuração de exemplo
cp config.sample.yml config.yml

# Sair da sessão wikijs
exit

Parte 6: Configuração do Wiki.js para PostgreSQL​

Editar o arquivo de configuração​

sudo nano /var/www/wikijs/config.yml

Substitua a seção db: por:​

port: 3000
bindIP: 0.0.0.0
db:
  type: postgres
  host: localhost
  port: 5432
  user: wikidb_user
  pass: StrongPassword123!
  db: wikidb
  ssl: false

Importante: Substitua StrongPassword123! pela senha que você definiu para wikidb_user.

Comentar as seções não utilizadas​

Certifique-se de que as seguintes seções estejam comentadas ou removidas se não forem utilizadas:

#  schema: public      # COMENTE se não utilizado
#  storage: path/to/database.sqlite  # COMENTE se não utilizado
#  sslOptions:         # COMENTE se não utilizado
#    auto: true
#    rejectUnauthorized: false

Configuração para acesso externo​

Para que o Wiki.js seja acessível externamente:

bindIP: 0.0.0.0
port: 3000

Salve e saia com Ctrl + X, depois Y, depois Enter.

Parte 7: Criação do Serviço systemd​

Adicionar aos sudoers e definir senha para wikijs​

# Se ainda não fez
sudo passwd wikijs
sudo usermod -aG sudo wikijs

Criar o serviço​

sudo nano /etc/systemd/system/wikijs.service

Conteúdo do arquivo:

[Unit]
Description=Wiki.js
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/node server
Restart=always
User=wikijs
Environment=NODE_ENV=production
WorkingDirectory=/var/www/wikijs

[Install]
WantedBy=multi-user.target

Salve e saia.

Parte 8: Inicialização e Verificação​

# Recarregar a configuração do systemd
sudo systemctl daemon-reload

# Iniciar o serviço
sudo systemctl start wikijs

# Ativar o serviço na inicialização
sudo systemctl enable wikijs

# Verificar o status
sudo systemctl status wikijs

Parte 9: Solução de Problemas Comuns​

Se você ver erros como:

  • bad indentation of a mapping entry
  • Unable to read configuration file!

Verifique se você comentou ou removeu corretamente os blocos a seguir em config.yml:

#  sslOptions:
#    auto: true

#  schema: public

#  storage: path/to/database.sqlite

Depois reinicie:

sudo systemctl restart wikijs

Verificar os logs​

# Ver os logs do serviço
sudo journalctl -u wikijs.service --no-pager --lines=50

# Acompanhar os logs em tempo real
sudo journalctl -u wikijs.service -f

Parte 10: Acesso à Interface do Wiki.js​

No seu navegador: http://<IP_do_seu_servidor>:3000

Siga as instruções para criar uma conta de administrador e finalizar a instalação.

Parte 11: Ativando HTTPS (Opcional)​

# Instalar Certbot e o plugin Nginx
sudo apt update
sudo apt install certbot python3-certbot-nginx -y

# Liberar Nginx (HTTP e HTTPS)
sudo ufw allow 'Nginx Full'

# Obter um certificado SSL
sudo certbot --nginx

# Testar a renovação automática
sudo certbot renew --dry-run

Anexo 1: Explorando o PostgreSQL​

1. Conexão ao PostgreSQL​

# Conectar como superusuário
sudo -u postgres psql

# Ou conectar diretamente a um banco específico com um usuário
psql -U wikidb_user -d wikidb -h localhost

2. Comandos de Navegação no psql​

ComandoDescrição
\lLista todos os bancos de dados
\c nome_baseConectar a um banco
\dtLista as tabelas
\d nome_tabelaMostra a estrutura de uma tabela
\duLista os usuários
\dnLista os schemas
\dfLista as funções
\xAtiva o modo de exibição expandida
\qSair do psql

3. Exemplos de Consultas Úteis​

Tabelas, colunas e índices:​

-- Listar todas as tabelas de um schema
SELECT tablename FROM pg_tables WHERE schemaname = 'public';

-- Ver as colunas de uma tabela
SELECT column_name, data_type FROM information_schema.columns WHERE table_name = 'users';

-- Ver os índices
SELECT * FROM pg_indexes WHERE tablename = 'users';

Espaço e tamanhos:​

-- Tamanho de um banco
SELECT pg_size_pretty(pg_database_size('wikidb'));

-- Tamanho de uma tabela
SELECT pg_size_pretty(pg_total_relation_size('users'));

Atividade e sessões:​

-- Ver as conexões ativas
SELECT * FROM pg_stat_activity;

-- Ver os locks em andamento
SELECT * FROM pg_locks;

Schema atual:​

-- Ver o schema padrão do usuário conectado
SHOW search_path;

4. Exportação e Dump​

# Dump completo do banco (formato binário)
pg_dump -U wikidb_user -d wikidb -F c -f wikidb.dump

# Exportar em SQL legível
pg_dump -U wikidb_user -d wikidb -F p -f wikidb.sql

5. Limpeza e Verificação​

-- Encontrar tabelas vazias
SELECT schemaname, tablename
FROM pg_tables
WHERE schemaname = 'public'
AND NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = tablename);

-- Verificar as restrições
SELECT * FROM information_schema.table_constraints WHERE table_schema = 'public';

Anexo 2: Exercício - Dominando o Básico do PostgreSQL​

Objetivo​

Criar um banco de dados completo chamado coursdb, com um usuário dedicado, duas tabelas (etudiants, programmes), relações, inserções, consultas SQL e gestão de permissões.

Etapa 1 – Criar o Banco e o Usuário​

Como superusuário do PostgreSQL:

sudo -u postgres psql

No psql:

-- Criar um banco de dados
CREATE DATABASE coursdb;

-- Criar um usuário
CREATE USER cours_user WITH PASSWORD 'cours123';

-- Conceder todos os privilégios no banco
GRANT ALL PRIVILEGES ON DATABASE coursdb TO cours_user;

-- Sair
\q

Etapa 2 – Conectar ao Banco​

psql -U cours_user -d coursdb -h localhost

Etapa 3 – Criar as Tabelas​

-- Criar a tabela programmes
CREATE TABLE programmes (
    id SERIAL PRIMARY KEY,
    nom TEXT NOT NULL,
    niveau TEXT NOT NULL
);

-- Criar a tabela etudiants com relação para programmes
CREATE TABLE etudiants (
    id SERIAL PRIMARY KEY,
    nom TEXT NOT NULL,
    age INTEGER CHECK (age > 0),
    programme_id INTEGER REFERENCES programmes(id) ON DELETE CASCADE
);

Etapa 4 – Inserir Dados​

-- Inserir programas
INSERT INTO programmes (nom, niveau) VALUES
('Informatique', 'DEC'),
('Administration', 'AEC');

-- Inserir estudantes
INSERT INTO etudiants (nom, age, programme_id) VALUES
('Alice', 21, 1),
('Bob', 24, 1),
('Caroline', 20, 2);

Etapa 5 – Realizar Consultas​

-- Todos os estudantes
SELECT * FROM etudiants;

-- Nome dos estudantes com seu programa
SELECT e.nom AS etudiant, p.nom AS programme
FROM etudiants e
JOIN programmes p ON e.programme_id = p.id;

-- Contar estudantes por programa
SELECT p.nom, COUNT(e.id) AS total
FROM programmes p
LEFT JOIN etudiants e ON p.id = e.programme_id
GROUP BY p.nom;

Etapa 6 – Alterar ou Remover​

-- Alterar um estudante
UPDATE etudiants SET age = 22 WHERE nom = 'Alice';

-- Remover um estudante
DELETE FROM etudiants WHERE nom = 'Bob';

-- Remover um programa (causa remoção em cascata)
DELETE FROM programmes WHERE nom = 'Administration';

Etapa 7 – Gestão de Usuários​

-- Conectado como postgres
sudo -u postgres psql

-- Criar um usuário somente leitura
CREATE USER lecteur WITH PASSWORD 'readonly123';

-- Conectar ao banco
\c coursdb

-- Conceder acesso somente leitura
GRANT CONNECT ON DATABASE coursdb TO lecteur;
GRANT USAGE ON SCHEMA public TO lecteur;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO lecteur;

-- Aplicar automaticamente às futuras tabelas
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO lecteur;

\q

Bônus – Verificação​

-- Ver os usuários
\du

-- Listar as tabelas e ver suas permissões
\dt+

Anexo 3: Gerenciamento de Serviços e Portas​

Parte 1: Ver Todos os Portos Ativos​

Para ver todas as portas ativas (abertas, em escuta ou sendo usadas por serviços, incluindo Node.js) no Ubuntu 24.04, utilize vários comandos.

1. Com ss (substituto moderno do netstat)​

sudo ss -tuln

Explicação:

  • -t: TCP
  • -u: UDP
  • -l: portas em escuta (listening)
  • -n: sem resolução DNS (mais rápido)

2. Com lsof para ver qual processo usa qual porta​

sudo lsof -i -P -n

Filtrar apenas por Node.js:

sudo lsof -i -P -n | grep node

3. Com netstat (se instalado)​

sudo netstat -tulnp

Se não estiver instalado:

sudo apt install net-tools

4. Ver Todos os Processos Node.js em Execução​

ps aux | grep node

5. Ver Serviços Escutando em uma Porta Específica​

sudo lsof -i :3000
sudo lsof -i :8080

6. Exibir Portas com nmap (scan local)​

sudo apt install nmap
sudo nmap -sT -O localhost

Parte 2: Parar um Serviço Node.js Instalado com systemd​

Etapa 1 – Encontrar o Nome do Serviço​

Se não tiver certeza do nome exato do serviço, liste os serviços ativos relacionados ao Node.js:

systemctl | grep node

Ou liste todos os serviços ativos:

systemctl list-units --type=service

Você também pode procurar na pasta do systemd:

ls /etc/systemd/system/

Etapa 2 – Parar o Serviço​

Depois de encontrar o nome (ex. wikijs.service ou my-node-app.service):

sudo systemctl stop nome-do-serviço

Exemplo:

sudo systemctl stop wikijs.service

Etapa 3 – (Opcional) Desabilitar o Serviço na Inicialização​

sudo systemctl disable nome-do-serviço

Etapa 4 – (Opcional) Remover Completamente o Serviço​

sudo rm /etc/systemd/system/nome-do-serviço.service
sudo systemctl daemon-reload

Parte 3: Parar um Processo Node.js em uma Porta Específica​

Exemplo: Sua aplicação Node.js está rodando na porta 3100, e foi iniciada pelo usuário www-data via um processo node.

node      1064738   www-data   18u  TCP *:3100 (LISTEN)

Etapa 1 — Encontrar e Parar o Serviço systemd​

Se foi iniciado como serviço, o nome pode ser wikijs, nodeapp, app3100, etc.

Tente:

systemctl | grep 3100

ou mais geral:

systemctl | grep node

Etapa 2 — Parar o Serviço (se conhecido)​

Depois de encontrar o nome do serviço (ex. wikijs.service), faça:

sudo systemctl stop wikijs.service

Etapa 3 — Opcional: Matar o Processo Manualmente​

Se o serviço não parar ou não for um serviço systemd (por exemplo, iniciado manualmente por um script), você pode matar o processo diretamente:

sudo kill 1064738

ou de forma mais forçada:

sudo kill -9 1064738

Verificação​

Após parar:

sudo ss -tuln | grep 3100

ou

sudo lsof -i :3100

Não deve aparecer mais nada.

Parte 4: Serviço que Reinicia Automaticamente​

Se sua aplicação Node.js ainda escuta na porta 3100, e ela é reiniciada mesmo depois de você matá-la manualmente, isso indica que ela é gerenciada por um serviço ou supervisor que a reinicia automaticamente.

Etapas para Identificar e Parar Definitivamente​

1. Encontrar o Nome Real do Serviço​

Tente este comando para encontrar todos os serviços contendo "node" ou 3100:

sudo systemctl list-units --type=service | grep -i node

Ou mais amplo:

ps aux | grep node

Depois:

ps -fp <PID>

Isso mostrará qual script ou arquivo está sendo executado e por quem foi iniciado.

2. Verificar se pm2 está sendo usado​
which pm2 && pm2 list

Se pm2 estiver instalado, ele reinicia automaticamente sua app. Para pará-la definitivamente:

pm2 stop all
pm2 delete all
pm2 unstartup
3. Ver a Origem Exata do Processo​
sudo ls -l /proc/<PID>/exe
sudo cat /proc/<PID>/cmdline | tr '\0' ' '

Isso exibirá o caminho real do script Node.js, por exemplo:

/usr/bin/node /var/www/wiki/server.js
4. Encontrar os Arquivos .service Responsáveis​

Liste os arquivos em /etc/systemd/system/ e /lib/systemd/system/:

ls /etc/systemd/system/ | grep -i wiki
ls /lib/systemd/system/ | grep -i wiki

Ou mais amplo:

grep -r 3100 /etc/systemd/system/

Etapa Final: Desativação e Parada Completa​

Depois de identificar o nome real do serviço, faça:

sudo systemctl stop nome.service
sudo systemctl disable nome.service

Depois recarregue:

sudo systemctl daemon-reload
sudo systemctl reset-failed

Parte 5: Remoção Completa de um Serviço systemd​

Para remover definitivamente um serviço Node.js (ou qualquer outro serviço systemd), siga três etapas:

Etapa 1 — Encontrar o Nome Exato do Serviço​

Primeiro, liste todos os serviços systemd personalizados:

ls /etc/systemd/system/

Procure um arquivo que se pareça com:

  • wikijs.service
  • nodeapp.service
  • app3100.service
  • etc.

Você também pode filtrar:

ls /etc/systemd/system/ | grep -i wiki

Etapa 2 — Parar e Desabilitar o Serviço​

Supondo que o nome do arquivo seja wikijs.service, execute:

sudo systemctl stop wikijs.service
sudo systemctl disable wikijs.service

Etapa 3 — Remover o Arquivo de Definição do Serviço​

sudo rm /etc/systemd/system/wikijs.service

Depois, recarregue o systemd para aplicar as mudanças:

sudo systemctl daemon-reload
sudo systemctl reset-failed

(Opcional) Verificar se Não Existe Mais​

systemctl list-units --type=service | grep wiki

ou

systemctl status wikijs.service

Você deve ver uma mensagem como:

Unit wikijs.service could not be found.

Comandos Úteis​

# Listar todos os serviços personalizados
ls -l /etc/systemd/system/

# Procurar um serviço específico
grep -r ExecStart /etc/systemd/system/

# Analisar o processo exato pelo PID
ps -fp <PID>
sudo cat /proc/<PID>/cmdline | tr '\0' ' '

Anexo 4: O que é pm2?​

No contexto do Node.js, pm2 significa Process Manager 2, uma ferramenta muito utilizada para:

  • Executar aplicações Node.js em segundo plano
  • Mantê-las vivas mesmo após um crash
  • Reiniciá-las automaticamente na inicialização do sistema
  • Gerenciar múltiplos processos Node.js facilmente

Por que o pm2 pode ser o responsável​

Mesmo que você pare um serviço Node.js manualmente (kill, systemctl, etc.), o pm2 pode automaticamente:

  • Reiniciar a aplicação
  • Restaurar os processos na inicialização da máquina (se pm2 startup foi executado)

Por isso é importante verificar se o pm2 está ativo.

Comandos para Parar Completamente o pm2​

  1. Verificar se o pm2 está instalado:
which pm2 && pm2 list
  1. Parar todos os processos gerenciados pelo pm2:
pm2 stop all
  1. Remover os processos registrados:
pm2 delete all
  1. Desabilitar o reinício automático na inicialização:
pm2 unstartup
  1. Opcional: Desinstalar o pm2 se não for mais necessário:
npm uninstall -g pm2

Resumo dos Comandos Importantes​

ComandoDescrição
sudo ss -tulnVer todas as portas em escuta
sudo lsof -i -P -nVer processos usando portas
sudo systemctl status wikijsVerificar o status de um serviço
sudo systemctl stop wikijsParar um serviço
sudo systemctl disable wikijsDesabilitar um serviço na inicialização
sudo journalctl -u wikijs.service -fAcompanhar logs em tempo real
ps aux | grep nodeVer todos os processos Node.js
pm2 listVer processos gerenciados pelo pm2

Verificação Final​

Verifique se você conseguiu:

  • Instalar Git e Node.js
  • Instalar e configurar PostgreSQL
  • Criar o banco de dados e o usuário para o Wiki.js
  • Baixar e extrair o Wiki.js
  • Configurar o arquivo config.yml para PostgreSQL
  • Criar e ativar o serviço systemd
  • Acessar o Wiki.js pelo navegador
  • Explorar o PostgreSQL com comandos psql
  • Entender o gerenciamento de serviços systemd
  • Saber parar e remover um serviço

Perguntas para Reflexão​

  1. Qual a diferença entre PostgreSQL e MariaDB?

    • Em quais casos você usaria um ou outro?

  2. Por que é importante comentar as seções não utilizadas no config.yml?

    • Explique os erros YAML e como evitá-los

  3. Qual a diferença entre systemctl stop e systemctl disable?

    • Quando você usaria cada um desses comandos?

  4. O que é o pm2 e por que ele pode causar problemas ao parar um serviço?

    • Como verificar se o pm2 está sendo utilizado?

  5. Explique a diferença entre bindIP: 127.0.0.1 e bindIP: 0.0.0.0

    • Em quais casos você usaria cada uma dessas configurações?

Próximos Passos​

  • Lab 5.7: Instalação do Wiki.js com MariaDB
  • Módulo 8: Serviços e daemons (para aprofundar em systemd)
  • TP 2: Reverse Proxy NGINX (para expor o Wiki.js via reverse proxy)

Recursos Complementares​

Lab criado em: Dezembro de 2024