Outline è un software open source, collaborativo e di knowledge base. Puoi usarlo per ospitare la documentazione e le pagine dei fan o persino usarlo per la condivisione di note. Include un editor di markdown e si integra con più servizi come Slack, Figma, Airtable, Google Docs, Trello, Zapier, Codepen, Spotify, Youtube, ecc. Dispone di 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 usando React e Node.js. Ci sono due modi per usare Outline. Uno è 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 usando Docker.
Prerequisiti
-
Un server che esegue Ubuntu 20.04 con un minimo di 1 GB di RAM.
-
Un utente non root con privilegi sudo.
-
Un nome di dominio che punta al server. Useremo
https://outline.example.comper il nostro tutorial. -
Poche app essenziali per iniziare.
$ sudo apt install nano curl wget unzip gnupg
Passaggio 1:configurazione del 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 quando lo si abilita.
$ sudo ufw allow OpenSSH
Consenti anche le 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
Ricontrolla 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
Dovremo installare Docker usando il suo repository ufficiale. Aggiungi la chiave GPG ufficiale di Docker.
$ 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
Verifica 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:installazione di Docker Compose
Esegui il comando seguente per installare Docker Compose. Docker Compose è stato aggiornato di recente alla v2.0, che ha introdotto molte modifiche sostanziali. Utilizzeremo l'ultima versione 1.x disponibile dalla sua 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
Applica l'autorizzazione eseguibile al binario di composizione Docker.
$ sudo chmod +x /usr/local/bin/docker-compose
Verifica se Docker Compose è installato correttamente.
$ docker-compose --version docker-compose version 1.29.2, build 5becea4c
Installa il completamento del comando per 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
Questo completa la sezione di installazione di Docker e Docker per la composizione del tutorial.
Passaggio 4:crea 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 di Slack.
Fai clic su Crea un'app pulsante per procedere. Fai clic su Da zero link per creare l'app.
Seleziona un nome per la tua app e scegli l'area di lavoro in cui desideri 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 su Crea app pulsante una volta terminato. Quindi, scorri verso il basso fino alla fine della pagina e dai alla tua app una descrizione, un'icona e un colore di sfondo.
Fai clic su Salva modifiche pulsante una volta terminato. Seleziona OAuth e autorizzazioni opzione dalla barra laterale sinistra.
Aggiungi l'URL di reindirizzamento https://outline.example.com/auth/slack.callback nell'apposita casella e fare clic su Aggiungi pulsante.
Fai clic su Salva URL pulsante per procedere. Scorri verso il basso fino a Ambiti token utente sezione della pagina e seleziona i seguenti ambiti dal menu a discesa.
identity.avataridentity.basicidentity.emailidentity.team
Torna alle Informazioni di base pagina dalla barra laterale sinistra. Copia i valori ID cliente e Segreto cliente dalle loro caselle in Credenziali app .
Configura l'integrazione Slack
Visita i Comandi Barra opzione dalla barra laterale sinistra.
Fai clic su Nuovo comando pulsante nella pagina risultante. Inserisci /outline come il comando. Inserisci https://outline.example.com/api/hooks.slack come URL di richiesta . Inserisci una descrizione per il tuo comando e una parola come suggerimento. Fai clic su Salva pulsante in basso al termine.
Apri il menu Caratteristiche>> Interattività e Scorciatoie dalla barra laterale sinistra. Abilita Interattività cambiando il pulsante di attivazione/disattivazione e incollando https://outline.example.com/api/hooks.interactive come URL della richiesta. Fai clic su Salva modifiche pulsante per terminare.
Apri le Impostazioni>> Installa app pagina dalla barra laterale sinistra e fare clic su Installa in WorkSpace pulsante per installare l'app per il tuo spazio di lavoro Slack.
Visita le Informazioni di base pagina dalla barra laterale sinistra e copia ID app e Token di verifica valori 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 il seguente codice JSON per la configurazione della condivisione delle risorse cross-origin (CORS). Sostituisci il valore di AllowedOrigins con l'URL della 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 il 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à. Esegui due volte il comando seguente per generare entrambe le chiavi.
$ openssl rand -hex 32
Copia e salva questi valori.
Crea e modifica il file dell'ambiente
Crea una directory per le impostazioni della finestra mobile per Outline.
$ mkdir ~/outline
Passa alla directory.
$ cd ~/outline
Crea il docker.env file e aprilo per la modifica. Questo file memorizzerà tutte le variabili di ambiente richieste per l'installazione.
$ nano docker.env
Incolla il codice seguente al suo interno. Immettere la chiave segreta e il segreto di utilità 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 monitorare le 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 monitoraggio.
Per il WEB_CONCURRENCY variabile, dividi la tua ram di sistema per 512 e inserisci il valore approssimativo. Il FORCE_HTTPS variabile è impostata su false poiché stiamo usando 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:[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
Il file sopra è basato sul file di esempio dal repository Github di Outline. Se devi configurare eventuali impostazioni aggiuntive, puoi copiarle da esso nel tuo file.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passaggio 5:crea un file di composizione Docker per la struttura
Crea il docker-compose.yml file 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 struttura
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 Let's Encrypt, è necessario scaricare lo strumento Certbot. Utilizzeremo il programma di installazione del pacchetto Snapd per questo.
Installa il programma di installazione Snap.
$ sudo apt install snapd
Assicurati che la tua versione di Snapd sia aggiornata.
$ sudo snap install core && sudo snap refresh core
Installa Certbot.
$ sudo snap install --classic certbot
Utilizzare il comando seguente per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico al /usr/bin directory.
$ 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 [email protected] -d outline.example.com
Il comando precedente scaricherà un certificato in /etc/letsencrypt/live/outline.example.com directory sul tuo server.
Genera un gruppo Diffie-Hellman certificato.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Crea una directory webroot di sfida per il rinnovo automatico di Let's 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, prima crea il file /etc/cron.daily/certbot-renew e aprilo per la modifica.
$ 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.
Modifica 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 di Nginx.
$ 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 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
Aggiorna i repository di sistema.
$ sudo apt update
Installa Nginx.
$ sudo apt install nginx
Verifica l'installazione.
$ nginx -v nginx version: nginx/1.20.2
Abilita il servizio Nginx.
$ sudo systemctl enable nginx
Passaggio 9 - Configura Nginx
Fino ad ora, Shlink è stato eseguito sul sistema locale tramite la porta 8080. Useremo Nginx per agire come proxy inverso per l'esecuzione sul suo dominio.
Crea un file di configurazione per il server Shlink in /etc/nginx/conf.d directory.
$ 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
Aggiungi 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.
Verifica la sintassi del file di configurazione 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
Fase 10 - Schema di accesso
Avvia il dominio https://outline.example.com nel tuo browser e sarai accolto con la seguente pagina.
Fai clic su 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 farlo, apri il tuo spazio di lavoro slack e digita /outline <searchterm> nei messaggi e postali.
Individuerà automaticamente il documento relativo al termine di ricerca e lo pubblicherà nei tuoi messaggi.
Passaggio 11 - Aggiorna struttura
Per aggiornare il wiki di Outline, esegui i seguenti comandi. Il primo comando si spegne e rimuove i contenitori. Il secondo estrae l'ultima versione delle immagini Docker per Outline e altri strumenti. Puoi eseguire gli stessi comandi se devi apportare modifiche al file di composizione Docker o al file di ambiente.
$ docker-compose down --remove-orphans $ docker-compose pull
Esegui 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.