Outline est un logiciel de base de connaissances open source et collaboratif. Vous pouvez l'utiliser pour héberger la documentation et les pages de fans ou même l'utiliser pour le partage de notes. Il comprend un éditeur de démarquage et s'intègre à plusieurs services tels que Slack, Figma, Airtable, Google Docs, Trello, Zapier, Codepen, Spotify, Youtube, etc. Il dispose de fonctionnalités de sécurité telles que des groupes d'utilisateurs avec des autorisations de lecture et d'écriture distinctes, permet le partage public et prend en charge RTL avec des traductions en 13 langues. Il est construit à l'aide de React et Node.js. Il existe deux manières d'utiliser Outline. L'une est leur version hébergée dans le cloud, ou vous pouvez l'héberger sur votre serveur.
Ce didacticiel vous apprendra comment installer Outline Wiki sur un serveur basé sur Ubuntu à l'aide de Docker.
Prérequis
-
Un serveur exécutant Ubuntu 20.04 avec un minimum de 1 Go de RAM.
-
Un utilisateur non root avec des privilèges sudo.
-
Un nom de domaine pointant vers le serveur. Nous utiliserons
https://outline.example.compour notre tutoriel. -
Quelques applications essentielles pour commencer.
$ sudo apt install nano curl wget unzip gnupg
Étape 1 - Configurer le pare-feu
La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (pare-feu non compliqué) par défaut.
Vérifiez si le pare-feu est en cours d'exécution.
État $ sudo ufw
Vous devriez obtenir le résultat suivant.
Statut :inactif
Autorisez le port SSH afin que le pare-feu n'interrompe pas la connexion actuelle en l'activant.
$ sudo ufw autorise OpenSSH
Autorisez également les ports HTTP et HTTPS.
$ sudo ufw allow 80$ sudo ufw allow 443
Activez le pare-feu.
$ sudo ufw enableCommand peut perturber les connexions ssh existantes. Continuer avec l'opération (o|n) ? yLe pare-feu est actif et activé au démarrage du système
Vérifiez à nouveau l'état du pare-feu.
État $ sudo ufw
Vous devriez voir une sortie similaire.
Statut :activeTo Action From-- ------ ----OpenSSH AUTORISER Partout80 AUTORISER Partout443 AUTORISER PartoutOpenSSH (v6) AUTORISER Partout (v6)80 (v6) AUTORISER Partout (v6)443 (v6) AUTORISER Partout (v6)
Étape 2 - Installer Docker
Nous devrons installer Docker en utilisant son référentiel officiel. Ajoutez la clé GPG officielle de Docker.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
Ajoutez le référentiel Docker au système.
$ 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
Mettez à jour la liste des référentiels APT et installez Docker.
$ sudo apt update$ sudo apt install docker-ce
Vérifiez si le moteur Docker est correctement installé.
$ docker --versionDocker version 20.10.14, build a224086
Exécutez les commandes suivantes afin de ne pas avoir à utiliser sudo pour exécuter les commandes Docker.
$ sudo usermod -aG docker ${USER}$ su - ${USER} Étape 3 - Installer Docker Compose
Exécutez la commande suivante pour installer Docker compose. Docker Compose a été récemment mis à jour vers la v2.0, ce qui a introduit de nombreux changements de rupture. Nous utiliserons la dernière version 1.x disponible sur sa page de versions 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
Appliquez l'autorisation exécutable au binaire de composition Docker.
$ sudo chmod +x /usr/local/bin/docker-compose
Vérifiez si Docker Compose est correctement installé.
$ docker-compose --versiondocker-compose version 1.29.2, build 5becea4c
Installer l'achèvement de la commande pour 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
Ceci termine la section d'installation de Docker et Docker compose du didacticiel.
Étape 4 - Créer un fichier d'environnement pour Docker
Configurer l'authentification Slack
Outline vous demande de configurer un fournisseur d'authentification. Pour notre tutoriel, nous allons configurer la connexion basée sur Slack.
Connectez-vous avec votre compte Slack et visitez la page des applications API de Slack.
Cliquez sur Créer une application bouton pour continuer. Cliquez sur De zéro lien pour créer l'application.
Sélectionnez un nom pour votre application et choisissez l'espace de travail dans lequel vous souhaitez que votre application apparaisse. Si vous ne souhaitez pas associer votre application à l'espace de travail existant, vous pouvez en créer un autre et revenir à cette étape.
Cliquez sur Créer une application bouton une fois que vous avez terminé. Ensuite, faites défiler vers le bas de la page et donnez à votre application une description, une icône et une couleur d'arrière-plan.
Cliquez sur Enregistrer les modifications bouton une fois que vous avez terminé. Sélectionnez OAuth et autorisations option dans la barre latérale gauche.
Ajoutez l'URL de redirection https://outline.example.com/auth/slack.callback dans la case prévue et cliquez sur Ajouter bouton.
Cliquez sur Enregistrer les URL bouton pour continuer. Faites défiler jusqu'à Étendues des jetons utilisateur section de la page et sélectionnez les champs d'application suivants dans le menu déroulant.
identity.avataridentity.basicidentity.emailidentity.team
Revenir aux informations de base page de la barre latérale gauche. Copiez les valeurs ID client et Secret client de leurs boîtes sous Identifiants d'application .
Configurer l'intégration Slack
Visitez les Commandes Slash option dans la barre latérale gauche.
Cliquez sur Nouvelle commande bouton sur la page résultante. Entrez /outline comme la commande. Saisissez https://outline.example.com/api/hooks.slack comme URL de demande . Entrez une description pour votre commande et un mot comme indice. Cliquez sur Enregistrer bouton en bas lorsque vous avez terminé.
Ouvrez le menu Fonctionnalités>> Interactivité et Raccourcis de la barre latérale gauche. Activer l'interactivité en basculant le bouton bascule et en collant https://outline.example.com/api/hooks.interactive comme URL de demande. Cliquez sur Enregistrer les modifications bouton pour terminer.
Ouvrez les Paramètres>> Installer l'application page dans la barre latérale gauche et cliquez sur Installer sur WorkSpace bouton pour installer l'application pour votre espace de travail Slack.
Consultez les informations de base page dans la barre latérale gauche et copiez App ID et jeton de vérification valeurs pour l'intégration de l'application Slack.
Créer des identifiants S3
Créez un compartiment S3 pour votre installation Outline sur AWS ou tout service compatible S3. Après avoir créé le compartiment, ajoutez la stratégie JSON suivante pour configurer le partage des ressources cross-origin (CORS). Remplacez la valeur de AllowedOrigins avec votre URL de contour.
[ { "AllowedHeaders":[ "*" ], "AllowedMethods":[ "PUT", "POST" ], "AllowedOrigins":[ "https://docs.mycompany.com" ], "ExposeHeaders" :[] }, { "AllowedHeaders":[], "AllowedMethods":[ "GET" ], "AllowedOrigins":[ "*" ], "ExposeHeaders":[] }]
Créez un utilisateur IAM avec la stratégie suivante. Remplacez le my-bucket-name avec le nom réel de votre compartiment 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/*" } ]}
Maintenant que vous avez créé votre utilisateur IAM, générez une clé d'accès et un secret pour votre utilisateur de compartiment.
Créer des clés secrètes
Le fichier d'environnement nécessite une clé secrète et un secret d'utilitaire. Exécutez la commande suivante deux fois pour générer les deux clés.
$ openssl rand -hex 32
Copiez et enregistrez ces valeurs.
Créer et modifier le fichier d'environnement
Créez un répertoire pour les paramètres du docker pour Outline.
$ mkdir ~/outline
Basculez vers le répertoire.
$ cd ~/outline
Créez le fichier docker.env fichier et ouvrez-le pour le modifier. Ce fichier stockera toutes les variables d'environnement nécessaires à l'installation.
$ nano docker.env
Collez-y le code suivant. Entrez la clé secrète et le secret des utilitaires créés auparavant. Copiez les informations d'identification Slack créées précédemment pour l'authentification et l'intégration de l'application. Saisissez vos informations d'identification Amazon S3 comme indiqué ci-dessous.
Si vous souhaitez utiliser Google Analytics pour suivre les statistiques de votre application Outline, saisissez votre ID Analytics dans le champ ci-dessous. Pour l'instant, Outline ne prend pas en charge les balises GA4, vous devrez donc saisir votre ancien ID de suivi.
Pour le WEB_CONCURRENCY variable, divisez votre ram système par 512 et entrez la valeur approximative. Le FORCE_HTTPS la variable est définie sur false puisque nous utilisons Nginx comme serveur proxy.
# –––––––––––––––– REQUIRED ––––––––––––––––SECRET_KEY=generate_a_new_keyUTILS_SECRET=generate_a_new_keyPOSTGRES_USER=outlinepgPOSTGRES_PASSWORD=yourpasswordPOSTGRES_DB=outlineDATABASE_URL=postgres ://outlinepg:[email protected]:5432/outlineDATABASE_URL_TEST=postgres://outlinepg:[email protected]:5432/outline-testPGSSLMODE=disableREDIS_URL=redis://localhost:6379URL=https://docs.example.comPORT ==3000AWS_ACCESS_KEY_ID get_a_key_from_awsAWS_SECRET_ACCESS_KEY =get_the_secret_of_above_keyAWS_REGION =us-est-2AWS_S3_UPLOAD_BUCKET_URL =https://my-bucket-name.s3.us-east-2.amazonaws.comAWS_S3_UPLOAD_BUCKET_NAME=my-bucket-nameAWS_S3_UPLOAD_MAX_SIZE=26214400AWS_S3_FORCE_PATH_STYLE=true# ----- ––––––––– AUTHENTIFICATION ––––––––––––––SLACK_KEY=SLACK_SECRET=# ––––––––––––––– – FACULTATIF –––––––––––––––– GOOGLE_ANALYTICS_ID=UA-XXXXXXX-1SLACK_VERIFICATION_TOKEN=votre_jetonSLACK_APP_ID=A0XXXXXXXSLACK_MESSAGE_ACTIONS=trueFORCE_HTTPS=falseENABLE_UPDATES=trueWEB_CONCURRENCY=2
Le fichier ci-dessus est basé sur l'exemple de fichier du référentiel Github d'Outline. Si vous devez configurer des paramètres supplémentaires, vous pouvez les copier dans votre fichier.
Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.
Étape 5 - Créer un fichier Docker Compose pour Outline
Créez le docker-compose.yml fichier et ouvrez-le pour le modifier.
$ nano docker-compose.yml
Collez-y le code suivant.
version :"3"services :contour :image :contourwiki/outline:latest redémarrage :toujours commande :sh -c "yarn sequelize:migrate --env=production-ssl-disabled &&yarn start --env=production- ssl-disabled" fichier_env :ports ./docker.env :- "3000:3000" dépend de :- postgres - redis redis :image :redémarrage de redis :toujours fichier_env :ports ./docker.env :- volumes "6379:6379" :- ./redis.conf:/redis.conf commande :["redis-server", "/redis.conf"] postgres :image :postgres restart :toujours env_file :./docker.env ports :- "5432:5432" volumes :- data-base de données :/var/lib/postgresql/datavolumes :données-database :
Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.
Étape 6 - Installer le plan
Installez Outline en démarrant les conteneurs.
$ docker-compose up -d
Vérifiez l'état des conteneurs.
$ docker ps
Étape 7 - Installer SSL
Pour installer un certificat SSL avec Let's Encrypt, nous devons télécharger l'outil Certbot. Nous utiliserons le programme d'installation du package Snapd pour cela.
Installez le programme d'installation de Snap.
$ sudo apt install snapd
Assurez-vous que votre version de Snapd est à jour.
$ sudo snap install core &&sudo snap refresh core
Installez Certbot.
$ sudo snap install --classic certbot
Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers /usr/bin répertoire.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Générez un certificat SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d outline.example.com
La commande ci-dessus téléchargera un certificat dans /etc/letsencrypt/live/outline.example.com répertoire sur votre serveur.
Générer un groupe Diffie-Hellman certificat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Créez un répertoire racine Web de défi pour le renouvellement automatique de Let's Encrypt.
$ sudo mkdir -p /var/lib/letsencrypt
Créez une tâche Cron pour renouveler le SSL. Il s'exécutera tous les jours pour vérifier le certificat et le renouveler si nécessaire. Pour cela, créez d'abord le fichier /etc/cron.daily/certbot-renew et ouvrez-le pour le modifier.
$ sudo nano /etc/cron.daily/certbot-renew
Collez le code suivant.
#!/bin/shcertbot renouveler --cert-name outline.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.
Modifiez les autorisations sur le fichier de tâche pour le rendre exécutable.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Étape 8 - Installer Nginx
Ubuntu est livré avec une ancienne version de Nginx. Vous devez télécharger le dépôt officiel Nginx pour installer la dernière version.
Importez la clé de signature de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg>/dev/null
Ajoutez le référentiel pour la version stable 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
Mettez à jour les référentiels système.
Mise à jour $ sudo apt
Installez Nginx.
$ sudo apt install nginx
Vérifiez l'installation.
$ nginx -vnginx version :nginx/1.20.2
Activez le service Nginx.
$ sudo systemctl activer nginx
Étape 9 - Configurer Nginx
Jusqu'à présent, Shlink fonctionnait sur le système local via le port 8080. Nous utiliserons Nginx pour agir comme un proxy inverse pour fonctionner sur son domaine.
Créez un fichier de configuration pour le serveur Shlink dans /etc/nginx/conf.d répertoire.
$ sudo nano /etc/nginx/conf.d/outline.conf
Collez-y le code suivant.
serveur { nom_serveur contour.exemple.com ; écouter 443 ssl http2; écouter [::]:443 ssl http2 ; access_log /var/log/nginx/outline.access.log ; error_log /var/log/nginx/outline.error.log; certificat_ssl /etc/letsencrypt/live/outline.example.com/fullchain.pem ; clé_certificat_ssl /etc/letsencrypt/live/outline.example.com/privkey.pem ; ssl_trusted_certificate /etc/letsencrypt/live/outline.example.com/chain.pem ; ssl_session_timeout 1j ; ssl_session_cache partagé :MozSSL :10 m ; ssl_session_tickets désactivé ; ssl_protocols TLSv1.2 TLSv1.3 ; chiffrements_ssl -RSA-CHACHA20-POLY1305 :DHE-RSA-AES128-GCM-SHA256 :DHE-RSA-AES256-GCM-SHA384 ; ssl_stapling activé ; ssl_stapling_verify activé ; ssl_dhparam /etc/ssl/certs/dhparam.pem ; emplacement / { proxy_pass http://localhost:3000; proxy_set_header Mettre à jour $http_upgrade ; proxy_set_header Connexion "Mettre à niveau" ; proxy_set_header Hôte $hôte ; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;proxy_set_header Host $host; proxy_set_header Hôte $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 désactivé ; }}## Serveur de redirection HTTPS { écouter 80 ; écouter [::]:80 ; nom_serveur contour.exemple.com ; renvoie 301 https://$host$request_uri;}
Une fois que vous avez terminé, enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.
Ouvrez le fichier /etc/nginx/nginx.conf pour l'édition.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf; .
server_names_hash_bucket_size 64 ;
Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité. Validez à nouveau Nginx.
Vérifiez la syntaxe du fichier de configuration Nginx.
$ sudo nginx -tnginx :la syntaxe du fichier de configuration /etc/nginx/nginx.conf est oknginx :le test du fichier de configuration /etc/nginx/nginx.conf est réussi
Démarrez le serveur Nginx.
$ sudo systemctl start nginx
Étape 10 - Accéder au plan
Lancez le domaine https://outline.example.com dans votre navigateur, et vous serez accueilli avec la page suivante.
Cliquez sur Continuer avec Slack bouton pour vous connecter à Slack et connecter votre espace de travail.
Une fois connecté, la page d'accueil d'Outline s'ouvrira et vous pourrez commencer à y travailler.
L'application Outline pour Slack vous permet de rechercher et de coller le lien vers n'importe quel document depuis votre espace de travail. Pour ce faire, ouvrez votre espace de travail slack et tapez /outline <searchterm> dans les messages et publiez-les.
Il localisera automatiquement le document lié au terme de recherche et le publiera dans vos messages.
Étape 11 - Mettre à jour le plan
Pour mettre à jour le wiki Outline, exécutez les commandes suivantes. La première commande arrête et supprime les conteneurs. Le second extrait la dernière version des images Docker pour Outline et d'autres outils. Vous pouvez exécuter les mêmes commandes si vous devez apporter des modifications au fichier de composition Docker ou au fichier d'environnement.
$ docker-compose down --remove-orphans$ docker-compose pull
Exécutez la commande suivante pour mettre à niveau la base de données.
$ docker-compose run --rm outline yarn db:migrate --env=production-ssl-disabled
Démarrez le nouveau conteneur avec de nouvelles images tout en conservant vos données intactes.
$ docker-compose up -d
Conclusion
Ceci conclut notre didacticiel sur l'installation de Outline Knowledgebase Wiki sur un serveur Ubuntu 20.04 à l'aide de Docker. Si vous souhaitez en savoir plus sur Outline, vous pouvez suivre sa documentation officielle. Si vous avez des questions, postez-les dans les commentaires ci-dessous.