Come installare Outline Knowledgebase Wiki su Ubuntu utilizzando Docker

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa Docker
Passaggio 3 - Installa Docker Compose
Passaggio 4 - Crea file di ambiente per Docker
1. Configura l'autenticazione Slack
2. Configura l'integrazione Slack
3. Crea credenziali S3
4. Crea chiavi segrete
5. Crea e modifica il file dell'ambiente
Outline è un software di knowledge base open source, collaborativo. Puoi usarlo per ospitare la documentazione e le pagine dei fan o persino usarlo per condividere le note. Include un editor markdown e si integra con più servizi come Slack, Figma, Airtable, Google Docs, Trello, Zapier, Codepen, Spotify, Youtube, ecc. Ha funzionalità di sicurezza come gruppi di utenti con autorizzazioni di lettura e scrittura separate, consente la condivisione pubblica e ha il supporto RTL con traduzioni in 13 lingue. È costruito utilizzando React e Node.js. Esistono due modi per utilizzare Outline. Una è la loro versione ospitata nel cloud, oppure puoi ospitarla sul tuo server.
Questo tutorial ti insegnerà come installare Outline Wiki su un server basato su Ubuntu utilizzando Docker.
Prerequisiti
- A server running Ubuntu 20.04 with a minimum of 1GB of RAM.
- A non-root user with sudo privileges.
- A domain name pointing to the server. We will use https://outline.example.com for our tutorial.
- Few essential apps to get started.
```
$ sudo apt install nano curl wget unzip gnupg
```
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.
Controlla se il firewall è in esecuzione.
```
$ sudo ufw status
```
Dovresti ottenere il seguente output.
```
Status: inactive
```
Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.
```
$ sudo ufw allow OpenSSH
```
Consenti anche porte HTTP e HTTPS.
```
$ sudo ufw allow 80
$ sudo ufw allow 443
```
Abilita il firewall.
```
$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
```
Controlla di nuovo lo stato del firewall.
```
$ sudo ufw status
```
Dovresti vedere un output simile.
```
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)
```
Passaggio 2: installa Docker

Avremo bisogno di installare Docker utilizzando il suo repository ufficiale. Aggiungi la chiave GPG ufficiale di Dockers.
```
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```
Aggiungi il repository 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
```
Aggiorna l'elenco dei repository APT e installa Docker.
```
$ sudo apt update
$ sudo apt install docker-ce
```
Verificare se il motore Docker è installato correttamente.
```
$ docker --version
Docker version 20.10.14, build a224086
```
Esegui i seguenti comandi in modo da non dover utilizzare sudo per eseguire i comandi Docker.
```
$ sudo usermod -aG docker ${USER}
$ su - ${USER}
```
Passaggio 3: installa Docker Compose
Eseguire il seguente comando per installare Docker compose. Docker Compose è stato recentemente aggiornato alla versione 2.0, che ha introdotto molte modifiche importanti. Useremo l'ultima versione 1.x disponibile dalla pagina delle versioni di 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
```
Applicare l'autorizzazione eseguibile al file binario di composizione Docker.
```
$ sudo chmod +x /usr/local/bin/docker-compose
```
Verificare se Docker Compose è installato correttamente.
```
$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c
```
Installa il completamento del comando per la composizione di Docker.
```
$ 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
```
Questo completa la sezione di installazione di Docker e Docker compose dell'esercitazione.
Passaggio 4: creare un file di ambiente per Docker
Configura l'autenticazione Slack

Outline richiede la configurazione di un provider di autenticazione. Per il nostro tutorial, configureremo l'accesso basato su Slack.
Accedi con il tuo account Slack e visita la pagina delle app API Slack.
Fare clic sul pulsante Crea un'app per procedere. Fare clic sul collegamento From Scratch per creare l'app.
Seleziona un nome per la tua app e scegli l'area di lavoro in cui vuoi che appaia la tua app. Se non desideri associare la tua app all'area di lavoro esistente, puoi crearne un'altra e tornare a questo passaggio.
Fai clic sul pulsante Crea app una volta che hai finito. Successivamente, scorri verso il basso fino alla fine della pagina e assegna alla tua app una descrizione, un'icona e un colore di sfondo.
Fare clic sul pulsante Salva modifiche una volta terminato. Seleziona l'opzione OAuth e autorizzazioni dalla barra laterale di sinistra.
Aggiungi l'URL di reindirizzamento https://outline.example.com/auth/slack.callback nella casella fornita e fai clic sul pulsante Aggiungi.
Fare clic sul pulsante Salva URL per procedere. Scorri verso il basso fino alla sezione Ambiti token utente della pagina e seleziona i seguenti ambiti dal menu a discesa.
- identity.avatar
- identity.basic
- identity.email
- identity.team
Torna alla pagina Informazioni di base dalla barra laterale sinistra. Copia i valori Client ID e Client Secret dalle rispettive caselle in Credenziali app.
Configura l'integrazione Slack
Visita l'opzione Slash Commands dalla barra laterale sinistra.
Fare clic sul pulsante Nuovo comando nella pagina risultante. Immettere /outline come comando. Inserisci https://outline.example.com/api/hooks.slack come URL della richiesta. Inserisci una descrizione per il tuo comando e una parola come suggerimento. Fai clic sul pulsante Salva in basso al termine.
Apri il menu Funzioni >> Interattività e scorciatoie dalla barra laterale di sinistra. Abilita l'interattività spostando l'interruttore e incolla https://outline.example.com/api/hooks.interactive come URL della richiesta. Fare clic sul pulsante Salva modifiche per terminare.
Apri la pagina Impostazioni >> Installa app dalla barra laterale sinistra e fai clic sul pulsante Installa nell'area di lavoro per installare l'app per l'area di lavoro Slack.
Visita la pagina delle informazioni di base dalla barra laterale sinistra e copia i valori dell'ID app e del token di verifica per l'integrazione dell'app Slack.
Crea credenziali S3
Crea un bucket S3 per l'installazione di Outline su AWS o qualsiasi servizio compatibile con S3. Dopo aver creato il bucket, aggiungi la seguente policy JSON per la configurazione della condivisione delle risorse tra le origini (CORS). Sostituisci il valore di AllowedOrigins con il tuo URL struttura.
```
[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "PUT",
            "POST"
        ],
        "AllowedOrigins": [
            "https://docs.mycompany.com"
        ],
        "ExposeHeaders": []
    },
    {
        "AllowedHeaders": [],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedOrigins": [
            "*"
        ],
        "ExposeHeaders": []
    }
]
```
Crea un utente IAM con la seguente policy. Sostituisci my-bucket-name con il nome effettivo del tuo bucket Outline S3.
```
{
    "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/*"
        }
    ]
}
```
Ora che hai creato il tuo utente IAM, genera una chiave di accesso e un segreto per il tuo utente del bucket.
Crea chiavi segrete
Il file di ambiente richiede una chiave segreta e un segreto di utilità. Eseguire il seguente comando due volte per generare entrambe le chiavi.
```
$ openssl rand -hex 32
```
Copia e salva questi valori.
Creare e modificare il file dell'ambiente
Crea una directory per le impostazioni della finestra mobile per Outline.
```
$ mkdir ~/outline
```
Passa alla rubrica.
```
$ cd ~/outline
```
Crea il file docker.env e aprilo per la modifica. Questo file memorizzerà tutte le variabili d'ambiente richieste per l'installazione.
```
$ nano docker.env
```
Incolla il seguente codice al suo interno. Immettere la chiave segreta e il segreto utils creato in precedenza. Copia le credenziali Slack create in precedenza per l'autenticazione e l'integrazione dell'app. Inserisci le tue credenziali Amazon S3 come specificato di seguito.
Se desideri utilizzare Google Analytics per tenere traccia delle statistiche della tua applicazione Outline, inserisci il tuo ID Analytics nel campo sottostante. Per ora, Outline non supporta i tag GA4, quindi dovrai inserire il tuo vecchio ID di tracciamento.
Per la variabile WEB_CONCURRENCY, dividi la ram di sistema per 512 e inserisci il valore approssimativo. La variabile FORCE_HTTPS è impostata su false poiché stiamo utilizzando Nginx come server 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::5432/outline
DATABASE_URL_TEST=postgres://outlinepg::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
```
Il file sopra è basato sul file di esempio dal repository Github di Outlines. Se è necessario configurare impostazioni aggiuntive, è possibile copiarle nel file.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passaggio 5: crea il file Docker Compose per Outline
Crea il file docker-compose.yml e aprilo per la modifica.
```
$ nano docker-compose.yml
```
Incolla il seguente codice al suo interno.
```
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:
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passaggio 6: installa Outline
Installa Outline avviando i contenitori.
```
$ docker-compose up -d
```
Controlla lo stato dei contenitori.
```
$ docker ps
```
Passaggio 7: installa SSL
Per installare un certificato SSL utilizzando Lets Encrypt, dobbiamo scaricare lo strumento Certbot. Useremo il programma di installazione del pacchetto Snapd per questo.
Installa il programma di installazione di Snap.
```
$ sudo apt install snapd
```
Assicurati che la tua versione di Snapd sia aggiornata.
```
$ sudo snap install core && sudo snap refresh core
```
Installa Cerbot.
```
$ sudo snap install --classic certbot
```
Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
```
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
```
Genera un certificato SSL.
```
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d outline.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/outline.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
```
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
```
Crea una directory webroot di verifica per il rinnovo automatico di Lets Encrypt.
```
$ sudo mkdir -p /var/lib/letsencrypt
```
Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, per prima cosa, crea il file /etc/cron.daily/certbot-renew e aprilo per modificarlo.
```
$ sudo nano /etc/cron.daily/certbot-renew
```
Incolla il seguente codice.
```
#!/bin/sh
certbot renew --cert-name outline.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Modificare le autorizzazioni sul file dell'attività per renderlo eseguibile.
```
$ sudo chmod +x /etc/cron.daily/certbot-renew
```
Passaggio 8: installa Nginx
Ubuntu viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.
Importa la chiave di firma Nginxs.
```
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
	| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
```
Aggiungi il repository per la versione stabile di Nginxs.
```
$ 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
```
Aggiorna i repository di sistema.
```
$ sudo apt update
```
Installa Nginx.
```
$ sudo apt install nginx
```
Verificare l'installazione.
```
$ nginx -v
nginx version: nginx/1.20.2
```
Abilita il servizio Nginx.
```
$ sudo systemctl enable nginx
```
Passaggio 9: configurare Nginx
Fino ad ora, Shlink è stato eseguito sul sistema locale tramite la porta 8080. Useremo Nginx per fungere da proxy inverso da eseguire sul suo dominio.
Crea un file di configurazione per il server Shlink nella directory /etc/nginx/conf.d.
```
$ sudo nano /etc/nginx/conf.d/outline.conf
```
Incolla il seguente codice al suo interno.
```
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;
}
```
Al termine, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Apri il file /etc/nginx/nginx.conf per la modifica.
```
$ sudo nano /etc/nginx/nginx.conf
```
Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
```
server_names_hash_bucket_size  64;
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Convalida di nuovo Nginx.
Verificare la sintassi del file di configurazione di 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
```
Avvia il server Nginx.
```
$ sudo systemctl start nginx
```
Passaggio 10: accesso alla struttura
Avvia il dominio https://outline.example.com nel tuo browser e verrai accolto con la seguente pagina.
Fai clic sul pulsante Continua con Slack per accedere con Slack e connettere il tuo spazio di lavoro.
Una volta effettuato l'accesso, si aprirà la home page di Outline e potrai iniziare a lavorarci.
L'app Outline per Slack ti consente di cercare e incollare il collegamento a qualsiasi documento dall'interno del tuo spazio di lavoro. Per fare ciò, apri il tuo spazio di lavoro slack e digita /outline nei messaggi e pubblicali.
Individuerà automaticamente il documento relativo al termine di ricerca e lo pubblicherà nei tuoi messaggi.
Passaggio 11: aggiorna la struttura
Per aggiornare il wiki di Outline, esegui i seguenti comandi. Il primo comando arresta e rimuove i contenitori. Il secondo estrae l'ultima versione delle immagini Docker per Outline e altri strumenti. È possibile eseguire gli stessi comandi se è necessario apportare modifiche al file di composizione Docker o al file dell'ambiente.
```
$ docker-compose down --remove-orphans
$ docker-compose pull 
```
Eseguire il comando seguente per aggiornare il database.
```
$ docker-compose run --rm outline yarn db:migrate --env=production-ssl-disabled
```
Avvia il nuovo contenitore con nuove immagini mantenendo intatti i tuoi dati.
```
$ docker-compose up -d
```
Conclusione
Questo conclude il nostro tutorial sull'installazione di Outline Knowledgebase Wiki su un server Ubuntu 20.04 utilizzando Docker. Se vuoi saperne di più su Outline, puoi seguire la sua documentazione ufficiale. Se hai domande, pubblicale nei commenti qui sotto.

Come installare Outline Knowledgebase Wiki su Ubuntu utilizzando Docker

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa Docker

Passaggio 3: installa Docker Compose

Passaggio 4: creare un file di ambiente per Docker

Configura l'autenticazione Slack

Configura l'integrazione Slack

Crea credenziali S3

Crea chiavi segrete

Creare e modificare il file dell'ambiente

Passaggio 5: crea il file Docker Compose per Outline

Passaggio 6: installa Outline

Passaggio 7: installa SSL

Passaggio 8: installa Nginx

Passaggio 9: configurare Nginx

Passaggio 10: accesso alla struttura

Passaggio 11: aggiorna la struttura

Conclusione