Cómo instalar Wiki.js en CentOS 7

Instalador Wiki.js

Wiki.js es una aplicación wiki OpenSource moderna y potente basada en Node.js, Git y Markdown. Wiki.js se ejecuta en el motor increíblemente rápido de Node.js y está optimizado para conservar los recursos de la CPU. Algunas de las características de Wiki.js que vale la pena mencionar son:

  • Edición de Markdown, respaldada por Git
  • Liviano, pero extremadamente poderoso
  • Bellamente diseñado para la web moderna
  • Control de acceso integrado
  • Gestión intuitiva de activos
  • Motor de búsqueda incorporado

En este tutorial, lo guiaremos a través del proceso de instalación de Wiki.js versión 1 en un sistema operativo CentOS 7 utilizando NGINX como servidor proxy inverso, MongoDB como servidor de base de datos, PM2 como administrador de procesos y, opcionalmente, puede proteger la capa de transporte. mediante el uso del cliente acme.sh y la autoridad de certificación Let’s Encrypt para agregar compatibilidad con SSL.

Requisitos

Los requisitos para ejecutar Wiki.js son los siguientes:

  • Se requiere Node.js 6.11.1 a 10.x.
  • MongoDB versión 3.2 o posterior.
  • Git versión 2.7.4 o posterior.
  • Software de servidor web como NGINX, Apache, Caddy, H2O…
  • Un repositorio Git vacío (opcional).
  • Mínimo de 512 MB de RAM. Se recomienda 1 GB de RAM.
  • Alrededor de 300 MB de espacio en disco.
  • Nombre de dominio con registros DNS A/AAAA configurados.

requisitos previos

  • Un sistema operativo CentOS 7.
  • Un usuario no root con privilegios sudo.

Pasos iniciales

Compruebe su versión de CentOS:

cat /etc/centos-release

Configurar la zona horaria:

timedatectl list-timezones
sudo timedatectl set-timezone 'Region/City'

Actualice los paquetes de su sistema operativo (software). Este es un primer paso importante porque garantiza que tenga las últimas actualizaciones y correcciones de seguridad para los paquetes de software predeterminados de su sistema operativo:

sudo yum update -y

Instale algunos paquetes esenciales que son necesarios para la administración básica del sistema operativo CentOS:

sudo yum install -y curl wget vim unzip socat epel-release

Wiki.js requiere que instale Git versión 2.7.4 o superior. La versión predeterminada de Git en CentOS es demasiado antigua, por lo que deberá compilarla a partir del código fuente. Aquí están los comandos para compilarlo rápidamente:

# Remove existing git package if installed:
sudo yum remove -y git
sudo yum groupinstall -y "Development Tools"
sudo yum install -y gettext-devel openssl-devel perl-CPAN perl-devel zlib-devel curl-devel
wget https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.21.0.tar.gz && tar zxvf git-2.21.0.tar.gz
rm git-2.21.0.tar.gz
cd git-2.21.0
make configure
./configure make prefix=/usr/local all
sudo make prefix=/usr/local install
cd ~
which git
git --version

Paso 1: instale Node.js y npm

Wiki.js se basa en Node.js. Vamos a instalar la última versión recomendada para Wiki.js que es la versión 10 en el momento de escribir este artículo. En Linux, tiene algunas opciones de instalación de Node.js: binarios de Linux (x86/x64), código fuente o mediante administradores de paquetes. Usaremos una opción de administración de paquetes que facilita la instalación y actualización de Node.js.

Descargue e instale la última versión recomendada de Node.js desde el repositorio de NodeSource:

curl --silent --location https://rpm.nodesource.com/setup_10.x | sudo bash -
sudo yum install -y nodejs

NOTA: npm se distribuye con Node.js, lo que significa que cuando descarga Node.js, npm se instala automáticamente en su sistema.

Compruebe la versión de Node.js y npm:

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

Npm es un proyecto separado de Node.js y tiende a actualizarse con más frecuencia. Como resultado, incluso si acaba de descargar Node.js (y, por lo tanto, npm), probablemente necesite actualizar su npm. Afortunadamente, npm sabe cómo actualizarse. Para actualizar su npm, escriba esto en su terminal:

sudo npm install -g [email protected]

Este comando actualizará npm a la última versión estable.

Vuelva a verificar la versión de npm con:

npm -v
# 6.8.0

Y debería devolver el último número de versión.

Paso 2: instalar la base de datos MongoDB

Wiki.js necesita una base de datos para almacenar sus datos, y la versión estable actual de Wiki.js solo admite el motor de base de datos MongoDB. De acuerdo con eso, necesitaremos instalar la base de datos MongoDB.

Cree un archivo /etc/yum.repos.d/mongodb-org-4.0.repo para que pueda instalar MongoDB directamente usando yum.

Correr:

sudo vim /etc/yum.repos.d/mongodb-org-4.0.repo

Y complete el archivo con la siguiente configuración:

[mongodb-org-4.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc

Para instalar la última versión estable de MongoDB, emita el siguiente comando:

sudo yum install -y mongodb-org

Compruebe la versión de MongoDB:

mongo --version | head -n 1 && mongod --version | head -n 1
# MongoDB shell version v4.0.6
# db version v4.0.6

Inicie y habilite (configúrelo para que se inicie al reiniciar) el servicio MongoDB si aún no se ha iniciado y habilitado:

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

Paso 3: instale el cliente acme.sh y obtenga el certificado Let’s Encrypt (opcional)

No es necesario proteger su sitio web con HTTPS, pero es una buena práctica para asegurar el tráfico de su sitio. Para obtener un certificado SSL de Let’s Encrypt, utilizaremos el cliente acme.sh. Acme.sh es un software de shell UNIX puro para obtener certificados SSL de Let’s Encrypt sin dependencias.

Descargue e instale 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 ~

Compruebe la versión de acme.sh:

acme.sh --version
# v2.8.1

Obtener RSA y ECC/ECDSA certificados para su dominio/nombre de host:

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

Si desea certificados falsos para realizar pruebas, puede agregar el indicador –staging a los comandos anteriores.

Para enumerar sus certificados emitidos, puede ejecutar:

acme.sh --list

Cree carpetas para almacenar sus certificados. Usaremos /etc/letsencrypt pero puede ser cualquier cosa que prefiera para almacenar certificados SSL.

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

Instalar/copiar certificados en el directorio /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»


Después de ejecutar los comandos anteriores, sus certificados y claves estarán en:

  • Para RSA: directorio /etc/letsencrypt/example.com.
  • Para ECC/ECDSA: directorio /etc/letsencrypt/example.com_ecc.

Todos los certificados se renovarán automáticamente cada 60 días.

Después de obtener los certificados, salga del usuario raíz y regrese al usuario sudo normal:

exit

Paso 4: instalar y configurar NGINX

Wiki.js (o cualquier aplicación HTTP Node.js) puede ejecutarse sin ningún servidor web real (como NGINX o Apache). Sin embargo, se recomienda enfáticamente colocar un servidor web estándar frente a Wiki.js. Esto garantiza que pueda usar funciones como SSL, múltiples sitios web, almacenamiento en caché, etc. Usaremos NGINX en este tutorial, pero cualquier otro servidor funcionará, solo necesita configurarlo correctamente.

Descargue e instale NGINX:

sudo yum install -y nginx

Compruebe la versión de NGINX:

nginx -v
# nginx version: nginx/1.12.2

Habilite e inicie el servicio NGINX:

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

Ejecute sudo vim /etc/nginx/conf.d/wiki.js.conf y configure NGINX como un proxy inverso 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; } }

Lo único que necesita cambiar en la configuración anterior es la directiva server_name y, potencialmente, la directiva proxy_pass si decide configurar un puerto diferente al 3000. Wiki.js usa el puerto 3000 de forma predeterminada.

Compruebe la configuración de NGINX:

sudo nginx -t

Finalmente, para que los cambios surtan efecto, necesitamos recargar NGINX:

sudo systemctl reload nginx.service

Paso 5 – Instalar y configurar Wiki.js

Cree un directorio raíz de documentos en el que deba residir Wiki.js:

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

Navegue al directorio raíz del documento:

cd /var/www/wiki.js

Cambie la propiedad del directorio /var/www/wiki.js a su_usuario:

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

NOTA: Reemplace your_user en el comando anterior con su usuario no root que debería haber creado como requisito previo para este tutorial.

Desde el directorio /var/www/wiki.js, ejecute el siguiente comando para obtener e instalar la última aplicación Wiki.js:

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

Una vez que se completa la instalación, puede ejecutar el siguiente comando para ver la versión actualmente instalada de Wiki.js:

node wiki --version
# 1.0.117

Una vez completada la instalación, se le pedirá que inicie el asistente de configuración.

Entonces, inicie el asistente de configuración ejecutando:

node wiki configure

Con su navegador web, vaya a http://example.com y siga las instrucciones en pantalla. Todos los ajustes introducidos durante el asistente de configuración se guardan en el archivo config.yml. El asistente de configuración iniciará automáticamente Wiki.js por usted.

Primero, verá un mensaje de bienvenida. Haga clic en el «comienzo» botón:

Instalador Wiki.js

Aparecerá la siguiente página de «Comprobación del sistema». Si se cumplen todos los requisitos, haga clic en el botón «Continuar» botón.

Chequeo del sistema

Ingrese información general sobre su wiki y haga clic en «Continuar» botón:

Información general

Lea el aviso de «Consideraciones importantes» y haga clic en «Continuar» para el siguiente paso:

Importante a considerar

A continuación, conéctese a la base de datos y continúe:

Conexión de base de datos

Debería ver un mensaje que indica que Wiki.js se ha conectado correctamente a la base de datos. Haga clic en el «Continuar» botón:

Conexión a la base de datos exitosa

Establecer caminos y continuar:

establecer el camino

Configure el repositorio Git remoto si lo desea u omita este paso. Este paso es opcional pero muy recomendable:

Configurar el repositorio GIT remoto

A continuación, haga clic en el botón «Continuar»:

Continuar con la instalación

Cree una cuenta de administrador y haga clic en «Continuar» botón:

Crear una cuenta de administrador

Y finalmente, inicie Wiki.js:

Inicio Wiki.js

Espere alrededor de 30 segundos y debería ser redirigido a la página de inicio de Wiki.js:

Página de inicio de Wiki.js

La instalación está completa. Deberías wiki página de bienvenida:

Bienvenido a Wiki.js

Paso 6: configurar el administrador de procesos de PM2

De forma predeterminada, Wiki.js no se iniciará automáticamente después de reiniciar el sistema. Para que se inicie en el arranque, debemos configurar el administrador de procesos PM2. PM2 viene incluido con Wiki.js como un módulo npm local, por lo que no necesitamos instalar PM2 globalmente.

Dígale a PM2 que se configure como un servicio de inicio ejecutando:

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

Finalmente, guarde la configuración actual de PM2 ejecutando el comando:

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

Su Wiki.js ahora se ejecuta como un proceso en segundo plano, utilizando PM2 como su administrador de procesos.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *