Cómo instalar Outline Knowledgebase Wiki en Ubuntu usando Docker

Outline es un software de base de conocimientos de código abierto y colaborativo. Puedes utilizarlo para alojar la documentación y las páginas de fans o incluso utilizarlo para compartir notas. Incluye un editor markdown y se integra con múltiples servicios como Slack, Figma, Airtable, Google Docs, Trello, Zapier, Codepen, Spotify, Youtube, etc. Tiene características de seguridad como grupos de usuarios con permisos de lectura y escritura separados, permite compartir públicamente y tiene soporte RTL con traducciones en 13 idiomas. Está construido usando React y Node.js. Hay dos formas de utilizar Outline. Una es su versión alojada en la nube, o puedes alojarlo en tu servidor.

Este tutorial le enseñará cómo instalar Outline Wiki en un servidor basado en Ubuntu usando Docker.

Requisitos previos

• Un servidor con Ubuntu 20.04 con un mínimo de 1GB de RAM.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio que apunte al servidor. Utilizaremos https://outline.example.com para nuestro tutorial.
• Algunas aplicaciones esenciales para empezar.

  $ sudo apt install nano curl wget unzip gnupg
  

Paso 1 – Configurar el Firewall

El primer paso es configurar el firewall. Ubuntu viene con ufw (Uncomplicated Firewall) por defecto.

Compruebe si el cortafuegos se está ejecutando.

$ sudo ufw status

Debería obtener la siguiente salida.

Status: inactive

Permitir el puerto SSH para que el firewall no rompa la conexión actual al habilitarlo.

$ sudo ufw allow OpenSSH

Permitir los puertos HTTP y HTTPS también.

$ sudo ufw allow 80
$ sudo ufw allow 443

Habilite el Firewall.

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Compruebe de nuevo el estado del cortafuegos.

$ sudo ufw status

Debería ver una salida similar.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80                         ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80 (v6)                    ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Paso 2 – Instalar Docker

Necesitaremos instalar Docker utilizando su repositorio oficial. Añadir la clave GPG oficial de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Añade el repositorio de Docker al sistema.

$ echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualice la lista de repositorios de APT e instale Docker.

$ sudo apt update
$ sudo apt install docker-ce

Verifique si el motor Docker está instalado correctamente.

$ docker --version
Docker version 20.10.14, build a224086

Ejecute los siguientes comandos para no tener que usar sudo para ejecutar los comandos de Docker.

$ sudo usermod -aG docker ${USER}
$ su - ${USER}

Paso 3 – Instalar Docker Compose

Ejecute el siguiente comando para instalar Docker Compose. Docker Compose se actualizó a la versión 2.0 recientemente, lo que introdujo muchos cambios de ruptura. Utilizaremos la última versión 1.x disponible en su Página de versiones de Github.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Aplicar el permiso de ejecutable al binario de Docker compose.

$ sudo chmod +x /usr/local/bin/docker-compose

Verifique si Docker Compose está instalado correctamente.

$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

Instale la finalización de comandos para Docker Compose.

$ sudo curl \
	-L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose
$ source ~/.bashrc

Esto completa la sección de instalación de Docker y Docker compose del tutorial.Anuncio

Paso 4 – Crear un archivo de entorno para Docker

Configurar la autenticación de Slack

El esquema requiere que se configure un proveedor de autenticación. Para nuestro tutorial, configuraremos el inicio de sesión basado en Slack.

Inicie sesión con su cuenta de Slack y visite Página de aplicaciones de la API de Slack.

Haga clic en el botón Crear una aplicación para proceder. Haga clic en Desde cero enlace para crear la aplicación.

Seleccione un nombre para su aplicación y elija el espacio de trabajo donde quiere que aparezca su aplicación. Si no quieres asociar tu app con el espacio de trabajo existente, puedes crear otro y volver a este paso.

Haga clic en el Crear aplicación una vez que hayas terminado. A continuación, desplázate hasta el final de la página y dale a tu aplicación una descripción, un icono y un color de fondo.

Haga clic en el botón Guardar cambios una vez que haya terminado. Seleccione OAuth y Permisos de la barra lateral izquierda.

Añada la URL de redirección https://outline.example.com/auth/slack.callback en la casilla correspondiente y haga clic en el botón Añadir botón.

Haga clic en el Guardar URLs para continuar. Desplácese hacia abajo hasta el Ámbitos de los tokens de usuario de la página y seleccione los siguientes ámbitos en el menú desplegable.

• identity.avatar
• identity.basic
• identity.email
• identity.team

Publicidad

Volver a la Información básica de la barra lateral izquierda. Copie los valores ID de cliente y Secreto de cliente de sus casillas en Credenciales de la aplicación.

Configurar la integración de Slack

Visite la página Comandos de barra de la barra lateral izquierda.

Haga clic en el botón Nuevo comando en la página resultante. Introduzca /outline como comando. Introduzca https://outline.example.com/api/hooks.slack como comando URL de solicitud. Introduzca una descripción para su comando y una palabra como pista. Haga clic en el botón Guardar en la parte inferior cuando haya terminado.

Abrir el menú Características >> Interactividad y accesos directos de la barra lateral izquierda. Activar Interactividad cambiando el botón de alternancia y pegando https://outline.example.com/api/hooks.interactive como URL de solicitud. Haga clic en el botón Guardar cambios para terminar.

Abrir el Ajustes >> Instalar aplicación de la barra lateral izquierda y haga clic en el botón Instalar en el espacio de trabajo para instalar la aplicación en su espacio de trabajo de Slack.

Visite el Información básica de la barra lateral izquierda y copiar ID de la aplicación y Ficha de verificación valores para la integración de la aplicación slack.

Crear credenciales S3

Cree un cubo S3 para su instalación de Outline en AWS o en cualquier servicio compatible con S3. Después de crear el cubo, añada la siguiente política JSON para configurar el uso compartido de recursos entre orígenes (CORS). Sustituya el valor de AllowedOrigins por su URL de Outline.

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "PUT",
            "POST"
        ],
        "AllowedOrigins": [
            "https://docs.mycompany.com"
        ],
        "ExposeHeaders": []
    },
    {
        "AllowedHeaders": [],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedOrigins": [
            "*"
        ],
        "ExposeHeaders": []
    }
]

Cree un usuario IAM con la siguiente política. Sustituya el nombre de mi cubo por el nombre real de su cubo S3 de Outline.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:GetObjectAcl",
                "s3:DeleteObject",
                "s3:PutObject",
                "s3:GetObject",
                "s3:PutObjectAcl"
            ],
            "Resource": "arn:aws:s3:::my-bucket-name/*"
        }
    ]
}

Ahora que has creado tu usuario IAM genera una clave de acceso y un secreto para tu usuario del bucket.

Crear claves secretas

El archivo de entorno requiere una clave secreta y un secreto de utilidad. Ejecute el siguiente comando dos veces para generar ambas claves.

$ openssl rand -hex 32

Copie y guarde estos valores.

Crear y editar el archivo de entorno

Cree un directorio para la configuración de Docker para Outline.

$ mkdir ~/outline

Cambie al directorio.

$ cd ~/outline

Cree el archivo docker.env y ábralo para editarlo. Este archivo almacenará todas las variables de entorno necesarias para la instalación.

$ nano docker.env

Pegue el siguiente código en él. Introduce la clave secreta y el secreto de utilidades creados anteriormente. Copia las credenciales de Slack creadas anteriormente para la autenticación y la integración de la app. Introduce tus credenciales de Amazon S3 como se especifica a continuación.

Si desea utilizar Google Analytics para hacer un seguimiento de las estadísticas de su aplicación Outline, introduzca su ID de Analytics en el siguiente campo. Por ahora, Outline no es compatible con las etiquetas GA4, por lo que tendrá que introducir su antiguo ID de seguimiento.

Para la variable WEB_CONCURRENCY, divida la ram de su sistema entre 512 e introduzca el valor aproximado. La variable FORCE_HTTPS se establece en false ya que estamos usando Nginx como servidor proxy.

# –––––––––––––––– REQUIRED ––––––––––––––––
SECRET_KEY=generate_a_new_key
UTILS_SECRET=generate_a_new_key

POSTGRES_USER=outlinepg
POSTGRES_PASSWORD=yourpassword
POSTGRES_DB=outline
DATABASE_URL=postgres://outlinepg:[email protected]:5432/outline
DATABASE_URL_TEST=postgres://outlinepg:[email protected]:5432/outline-test
PGSSLMODE=disable
REDIS_URL=redis://localhost:6379

URL=https://docs.example.com
PORT=3000

AWS_ACCESS_KEY_ID=get_a_key_from_aws
AWS_SECRET_ACCESS_KEY=get_the_secret_of_above_key
AWS_REGION=us-east-2
AWS_S3_UPLOAD_BUCKET_URL=https://my-bucket-name.s3.us-east-2.amazonaws.com
AWS_S3_UPLOAD_BUCKET_NAME=my-bucket-name
AWS_S3_UPLOAD_MAX_SIZE=26214400
AWS_S3_FORCE_PATH_STYLE=true

# –––––––––––––– AUTHENTICATION ––––––––––––––
SLACK_KEY=<slackclientid>
SLACK_SECRET=<slackclientsecret>

# –––––––––––––––– OPTIONAL ––––––––––––––––
GOOGLE_ANALYTICS_ID=UA-XXXXXXX-1

SLACK_VERIFICATION_TOKEN=your_token
SLACK_APP_ID=A0XXXXXXX
SLACK_MESSAGE_ACTIONS=true

FORCE_HTTPS=false
ENABLE_UPDATES=true
WEB_CONCURRENCY=2

El archivo anterior se basa en el del repositorio Github de Outline. Si necesitas configurar algún ajuste adicional, puedes copiarlo de él a tu archivo.

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Paso 5 – Crear el archivo Docker Compose para el esquema

Cree el archivo docker-compose.yml y ábralo para editarlo.

$ nano docker-compose.yml

Pegue el siguiente código en él.

version: "3"
services:

  outline:
    image: outlinewiki/outline:latest
    restart: always
    command: sh -c "yarn sequelize:migrate --env=production-ssl-disabled && yarn start --env=production-ssl-disabled"
    env_file: ./docker.env
    ports:
      - "3000:3000"
    depends_on:
      - postgres
      - redis

  redis:
    image: redis
    restart: always
    env_file: ./docker.env
    ports:
      - "6379:6379"
    volumes:
      - ./redis.conf:/redis.conf
    command: ["redis-server", "/redis.conf"]

  postgres:
    image: postgres
    restart: always
    env_file: ./docker.env
    ports:
      - "5432:5432"
    volumes:
      - database-data:/var/lib/postgresql/data

volumes:
  database-data:

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Paso 6 – Instalar el esquema

Instale Outline iniciando los contenedores.

$ docker-compose up -d

Compruebe el estado de los contenedores.

$ docker ps

Paso 7 – Instalar SSL

Para instalar un certificado SSL usando Let’s Encrypt, necesitamos descargar la herramienta Certbot. Para ello utilizaremos el instalador de paquetes Snapd.

Instale el instalador de Snap.

$ sudo apt install snapd

Asegúrese de que su versión de Snapd está actualizada.

$ sudo snap install core && sudo snap refresh core

Instale Certbot.

$ sudo snap install --classic certbot

Utilice el siguiente comando para asegurarse de que el comando Certbot puede ser ejecutado creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Generar un certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d outline.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/outline.example.com de su servidor.

Generar un Grupo Diffie-Hellman certificado.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Crear un directorio webroot de desafío para la renovación automática de Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Crear un Cron Job para renovar el SSL. Se ejecutará cada día para comprobar el certificado y renovarlo si es necesario. Para ello, primero crea el archivo /etc/cron.daily/certbot-renew y ábrelo para editarlo.

$ sudo nano /etc/cron.daily/certbot-renew

Pegue el siguiente código.

#!/bin/sh
certbot renew --cert-name outline.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Cambie los permisos del archivo de la tarea para que sea ejecutable.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Paso 8 – Instalar Nginx

Ubuntu viene con una versión antigua de Nginx. Es necesario descargar el repositorio oficial de Nginx para instalar la última versión.

Importar la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
	| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Añadir el repositorio de la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Actualizar los repositorios del sistema.

$ sudo apt update

Instalar Nginx.

$ sudo apt install nginx

Verifique la instalación.

$ nginx -v
nginx version: nginx/1.20.2

Habilite el servicio Nginx.

$ sudo systemctl enable nginx

Paso 9 – Configurar Nginx

Hasta ahora, Shlink se ha estado ejecutando en el sistema local a través del puerto 8080. Utilizaremos Nginx para que actúe como proxy inverso y se ejecute en su dominio.

Cree un archivo de configuración para el servidor Shlink en el directorio /etc/nginx/conf.d.

$ sudo nano /etc/nginx/conf.d/outline.conf

Pegue el siguiente código en él.

server {
        server_name outline.example.com;

        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        access_log /var/log/nginx/outline.access.log;
        error_log /var/log/nginx/outline.error.log;

        ssl_certificate /etc/letsencrypt/live/outline.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/outline.example.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/outline.example.com/chain.pem;
        ssl_session_timeout 1d;
        ssl_session_cache shared:MozSSL:10m;
        ssl_session_tickets off;

        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;

        ssl_stapling on;
        ssl_stapling_verify on;
        ssl_dhparam /etc/ssl/certs/dhparam.pem;
 
        location / {
                proxy_pass http://localhost:3000;
                
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection "Upgrade";
                proxy_set_header Host $host;
        
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;proxy_set_header Host $host;
                proxy_set_header Host $http_host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Scheme $scheme;
                proxy_set_header X-Forwarded-Proto $scheme;
                proxy_redirect off;
        }
}

## HTTPS Redirect
server {
        listen 80; 
        listen [::]:80;
        server_name outline.example.com;
        return 301 https://$host$request_uri;
}

Una vez que haya terminado, guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Abra el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite. Vuelva a validar Nginx.

Verifique la sintaxis del archivo de configuración de Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Inicie el servidor Nginx.

$ sudo systemctl start nginx

Paso 10 – Esquema de acceso

Inicie el dominio https://outline.example.com en su navegador, y será recibido con la siguiente página.

Haga clic en el Continuar con Slack para iniciar sesión con Slack y conectar su espacio de trabajo.

Una vez iniciada la sesión, se abrirá la página de inicio de Outline y podrá empezar a trabajar en ella.

La aplicación Outline para Slack le permite buscar y pegar el enlace a cualquier documento desde su espacio de trabajo. Para ello, abre tu espacio de trabajo en Slack y escribe /outline <searchterm> en los mensajes y publícalos.

Localizará automáticamente el documento relacionado con el término de búsqueda y lo publicará en sus mensajes.

Paso 11 – Actualizar el esquema

Para actualizar el wiki Outline, ejecute los siguientes comandos. El primer comando cierra y elimina los contenedores. El segundo extrae la última versión de las imágenes Docker para Outline y otras herramientas. Puedes ejecutar los mismos comandos si necesitas hacer algún cambio en el archivo Docker compose o en el archivo de entorno.

$ docker-compose down --remove-orphans
$ docker-compose pull 

Ejecute el siguiente comando para actualizar la base de datos.

$ docker-compose run --rm outline yarn db:migrate --env=production-ssl-disabled

Inicie el nuevo contenedor con imágenes frescas manteniendo sus datos intactos.

$ docker-compose up -d

Conclusión

Con esto concluye nuestro tutorial sobre la instalación de Outline Knowledgebase Wiki en un servidor Ubuntu 20.04 utilizando Docker. Si quieres aprender más sobre Outline, puedes seguir su documentación oficial. Si tienes alguna pregunta, publícala en los comentarios más abajo.