Vous êtes ici : Accueil / Debian GNU/Linux / Applications Web / Divers / Installer Turtl sur Debian

Installer Turtl sur Debian

Par Pierre-Yves Landuré — Dernière modification 01/04/2018 10:01

Turtl est une alternative chiffrée et sécurisée à Evernote écrite en LISP. Ce guide facilite son installation sur Debian.

Ce guide est testé sur:

  • Debian 9.0 Stretch

Ce guide est testé avec ces versions de Turtl:

  • 0.4

Prérequis

Ce guide nécessite :

Paramètres

Renseignez le nom de domaine où sera disponible l'application:

domain='turtl.domain.com'

Renseignez l'identifiant de l'utilisateur d'administration:

adminEmail="firstname.lastname@gmail.com"

Renseignez le nom du certificat SSL à utiliser pour chiffrer l'application avec HTTPS (créé via la procédure Créer un certificat SSL / TLS sur Debian ou via Let's Encrypt) (optionnel, recommandé):

sslKeyName="auto"

Renseignez le nom d'hôte de votre instance RethinkDB (si vous ne savez pas de quoi il s'agit, ne modifiez pas cette valeur):

rethinkdbHost="localhost"

Renseignez le port de votre instance RethinkDB (si vous ne savez pas de quoi il s'agit, ne modifiez pas cette valeur):

rethinkdbPort=28015

Installation

Détectez le proxy de commande (command ou sudo):

cmdProxy='command'
command type -f 'sudo' >'/dev/null' && cmdProxy='sudo'

Déterminez le chemin d'installation:

installPath="/opt/turtl/${domain}"

Déterminez le chemin de l'API:

apiInstallPath="${installPath}/api"

Déterminez le chemin de l'interface Web:

webUiInstallPath="${installPath}/webui"

Déterminez l'utilisateur pour l'utilisation de composer:

turtlUser='turtl'

Déterminez le répertoire principal de l'utilisateur composer:

turtlHome="/var/lib/${turtlUser}"

Déterminez le chemin des données:

dataPath="${turtlHome}/${domain}"

Déterminez un port aléatoire pour l'instance du logiciel:

turtlPort=$((1024 + RANDOM))

Déterminez le protocole utilisé par l'application:

proto='http'
if [[ -n "${sslKeyName}" && ( -e "/etc/ssl/private/${sslKeyName}.key" || sslKeyName = 'auto' ) ]]; then
  proto='https'
fi

Préparation de l'environnement

Installez les logiciels nécessaires:

${cmdProxy} apt-get install build-essentials libuv1-dev cl-quicklisp git sudo make

Activez le module lisp:

${cmdProxy} a2enmod proxy_http

Rechargez la configuration d'Apache 2:

${cmdProxy} service 'apache2' 'force-reload'

Créez un utilisateur système dédié à composer:

${cmdProxy} adduser --system --disabled-password --group --home "${turtlHome}" "${turtlUser}"

Installez QuickLisp pour l'utilisateur:

sudo -u "${turtlUser}" ccl \
    --load "/usr/share/cl-quicklisp/quicklisp.lisp" \
    --eval "(progn (quicklisp-quickstart:install) (ccl:quit))"

Configurez le chargement automatique de QuickLisp:

sudo -u "${turtlUser}" ccl \
    --load "${turtlHome}/quicklisp/setup.lisp" \
    --eval "(progn (ql:add-to-init-file) (ccl:quit))"

Mise en place du serveur API (en LISP) de l'application

Assurez-vous de l'existence des dossiers:

${cmdProxy} mkdir -p "${installPath}"
${cmdProxy} chown -R ${turtlUser}:${turtlUser} "${installPath}"
${cmdProxy} mkdir -p "${dataPath}"
${cmdProxy} chown -R ${turtlUser}:${turtlUser} "${dataPath}"

Téléchargez la dernière version de l'API Turtl:

sudo -u "${turtlUser}" git clone 'https://github.com/turtl/api.git' "${apiInstallPath}"

Créez le fichier de configuration:

sudo -u "${turtlUser}" cp "${apiInstallPath}/config/config.default.lisp" "${apiInstallPath}/config/config.lisp"

Paramètrez l'application:

${cmdProxy} sed -i \
 -e "s|\*server-bind\*.*|*server-bind* \"127.0.0.1\"|" \
 -e "s|\*server-port\*.*|*server-port* ${turtlPort}|" \
 -e "s|\*db-name\*.*|*db-name* \"${domain//./_}\"|" \
 -e "s|\*db-host\*.*|*db-host* \"${rethinkdbHost}\"|" \
 -e "s|\*db-port\*.*|*db-port* ${rethinkdbPort}|" \
 -e "s|\*enabled-cors-resources\*.*|*enabled-cors-resources* \"resource://${domain}\"|" \
 -e "s|\*site-url\*.*|*site-url* \"${proto}://${domain}\"|" \
 -e "s|defvar \*api-path\*.*|defvar *api-path* \"/api\"|" \
 -e "s|\*admin-email\*.*|*admin-email* \"${adminEmail}\"|" \
 -e "s|\*email-from\*.*|*email-from* \"noreply@${domain#*.}\"|" \
 -e "s|\*smtp-host\*.*|*smtp-host* \"localhost\"|" \
 -e "s|:db \"analytics\"|:db \"${domain//./_}_analytics\"|" \
 -e "s|defvar \*local-upload\*.*|defvar *local-upload* \"${dataPath}\"|" \
 -e "s|defvar \*local-upload-url\*.*|defvar *local-upload-url* \"${proto}://${domain}\"|" \
  "${apiInstallPath}/config/config.lisp"

Si votre serveur n'est pas ouvert aux inscriptions, désactivez la limite de stockage:

${cmdProxy} sed -i \
    -e "s|\*default-storage-limit\*.*|*default-storage-limit* nil|" \
  "${apiInstallPath}/config/config.lisp"

Ajoutez le chemin de l'application à l'environnement du Quickload LISP:

sudo -u "${turtlUser}" tee -a "${turtlHome}/.ccl-init.lisp" \
<<< ";;; Turtl API for ${domain} quickload rule
(pushnew (truename \"${apiInstallPath}\") ql:*local-project-directories* )
(ql:register-local-projects)"

Lancez l'application pour la première fois:

${cmdProxy} -u "${turtlUser}" ccl --quiet --batch --load "${apiInstallPath}/start.lisp"

Si le serveur se lance correctement, désactivez l'affichage des erreurs:

${cmdProxy} sed -i \
    -e "s|\*production-error-handling\*.*|*production-error-handling* t|" \
    -e "s|\*display-errors\*.*|*display-errors* nil|" \
  "${apiInstallPath}/config/config.lisp"

Mettez en place un service pour lancer le logiciel en tache de fond:

${cmdProxy} tee "/etc/systemd/system/turtl-api-${domain//\./-}.service" <<< "[Unit]
Description=Turtl on ${domain}
Requires=network.target local-fs.target
After=rethinkdb@.service

[Install]
WantedBy=multi-user.target

[Service]
Type=simple
User=${turtlUser}
Group=${turtlUser}
Restart=always

ExecStart=$(which ccl) --quiet --batch --load \"${apiInstallPath}/start.lisp\"
ExecReload=/bin/kill -s HUP \$MAINPID
ExecStop=/bin/kill -s TERM \$MAINPID

WorkingDirectory=${apiInstallPath}

PrivateTmp=true"

Activez le service et ajoutez le au démarrage de l'hôte:

${cmdProxy} systemctl daemon-reload
${cmdProxy} systemctl enable "turtl-api-${domain//\./-}"

Démarrez le service:

sudo service "turtl-api-${domain//\./-}" start

Configuration de syslog

Syslog-NG

Renseignez la configuration Syslog-NG pour identifier les messages de la commande ccl:

syslogNgConf='
########################
# CCL (turtl) messages
########################

destination d_ccl { file("/var/log/ccl.log"); };
filter f_ccl { match("^[w: ]*ccl" value("PROGRAM")); };
log { source(s_src); filter(f_ccl); destination(d_ccl); };'

Configurez Syslog-NG (si présent) pour enregistrer les messages de PHP dans un fichier dédié:

if [ -d '/etc/syslog-ng/conf.d' ]; then
  ${cmdProxy} tee '/etc/syslog-ng/conf.d/ccl.conf' <<< "${syslogNgConf}"
elif [ -e '/etc/syslog-ng/syslog-ng.conf' \
    -a -z "$(command grep 'CCL (turtl) message' '/etc/syslog-ng/syslog-ng.conf' 2>'/dev/null')" ]; then
  ${cmdProxy} tee -a '/etc/syslog-ng/syslog-ng.conf' <<< "${syslogNgConf}"
fi

Créez le fichier journal pour Clozure Common Lisp:

if [ -d '/etc/syslog-ng/' ]; then
  ${cmdProxy} touch '/var/log/ccl.log'
  ${cmdProxy} chown root:adm '/var/log/ccl.log'
  ${cmdProxy} chmod 640 '/var/log/ccl.log'
fi

Rechargez la configuration de Syslog-NG:

${cmdProxy} service syslog-ng reload

Les messages du serveur API du logiciel sont disponibles dans le fichier "/var/log/ccl.log".

Mise en place de l'interface Web

Téléchargez la dernière version de l'interface Web du logiciel:

sudo -u "${turtlUser}" git clone 'https://github.com/turtl/js.git' "${webUiInstallPath}"

Initialisez le fichier de configuration:

sudo -u "${turtlUser}" cp "${webUiInstallPath}/config/config.js.default" "${webUiInstallPath}/config/config.js"

Configurez l'interface Web:

${cmdProxy} sed -i \
  -e "s|api_url:.*|api_url: '${proto}://${domain}/api',|" \
  -e "s|site_url:.*|site_url: '${proto}://${domain}',|" \
  "${webUiInstallPath}/config/config.js"

Installez les dépendances javascript de l'interface Web:

pushd "${webUiInstallPath}"
sudo -u "${turtlUser}" npm install
popd

Compilez les ressources:

pushd "${webUiInstallPath}"
sudo -u "${turtlUser}" make
popd

Mise en place de l'hôte virtuel

Créez la configuration du serveur HTTP pour le domaine:

if [[ -n "${sslKeyName}" && ( -e "/etc/ssl/private/${sslKeyName}.key" || "${sslKeyName}" = 'auto' ) ]]; then
  ${cmdProxy} a2tools --ssl="${sslKeyName}" --overrides='All' \
      --custom-options="
  <IfModule mod_rewrite.c>
    <IfModule mod_proxy.c>
      ProxyRequests Off
      ProxyPreserveHost On
      ProxyPassReverse  /api       http://127.0.0.1:${turtlPort}/api
      RewriteRule       ^/api(.*)  http://127.0.0.1:${turtlPort}/api\$1  [P,L]

      <Location /api>
        <IfVersion >= 2.4>
          Require all granted
        </IfVersion>

        <IfVersion < 2.4>
          Order deny,allow
          Allow from all
        </IfVersion>
      </Location>

    </IfModule>
  </IfModule>
" \
      "${domain}" "${webUiInstallPath}"
else
 ${cmdProxy} a2tools --overrides='All' \
 --custom-options="
 <IfModule mod_rewrite.c>
 <IfModule mod_proxy.c>
 ProxyRequests Off
 ProxyPreserveHost On
      ProxyPassReverse  /api       http://127.0.0.1:${turtlPort}/api
      RewriteRule       ^/api(.*)  http://127.0.0.1:${turtlPort}/api\$1  [P,L]

      <Location /api>
        <IfVersion >= 2.4>
          Require all granted
        </IfVersion>

        <IfVersion < 2.4>
          Order deny,allow
          Allow from all
        </IfVersion>
      </Location>

 </IfModule>
 </IfModule>
" \
 "${domain}" "${webUiInstallPath}"
fi

L'application est maintenant disponible sur le domaine.

Sauvegardes

Sauvegardez l'installation avec Backup Manager (voir Installer et configurer Backup Manager sur Debian):

${cmdProxy} backup-manager-tools add "${installPath}"
${cmdProxy} backup-manager-tools add "${dataPath}"

Remerciements