Installation

Installation de Scrumblr
Description
Scrumblr est un logiciel libre distribué sous licence GPLv3
qui a pour objectif de fournir un tableau de post-it
collaboratif en temps réel. Il s’agit de la solution
logicielle qui propulse le service en ligne Framemo. Du point
de vue utilisateur, seul un navigateur Web est nécessaire.
Nous allons dans ce tutoriel voir la manière d’installer la
partie serveur.
Ce guide est prévu pour Debian Stable. À l’heure où nous
écrivons ces mots, il s’agit de Debian 8.5 Jessie. Nous
partons du principe que vous venez d’installer le système, que
celui-ci est à jour et que vous avez déjà installé le serveur
web Nginx.
Nourrir la terre
NodeJS
Scrumblr est une application développée avec le langage de
programmation JavaScript et s’appuie sur la plate-forme
NodeJS. Malheureusement la version de NodeJS disponible dans
les dépôts Debian est assez ancienne. Nous allons installer
NodeJS 4 depuis les dépôts de l’éditeur.
curl
-sL
https://deb.nodesource.com/setup_4.x
/tmp/install_node_depot.sh
>
On vérifie le contenu de /tmp/install_node_depot.sh pour
vérifier que le script ne fait rien de dangereux (on va le
lancer en root quand même !), puis on le lance et on installe
NodeJs :
nano /tmp/install_node_depot.sh
sudo bash /tmp/install_node_depot.sh
sudo apt-get install -y nodejs
Redis
Redis est le serveur de base de données de Scrumblr. La
version de Debian stable ira bien, il suffit pour l’installer
de faire :
sudo apt-get install redis-server
Utilisateur dédié
De manière à mieux isoler l’application, nous allons créer un
utilisateur dédié à Scrumblr, du même nom que le logiciel :
sudo adduser --no-create-home --home /var/www/scrumblr -disabled-login --gecos "Scrumblr" scrumblr
Cette commande crée l’utilisateur scrumblr ainsi qu’un groupe
du même nom. Il lui assigne comme répertoire personnel
/var/www/scrumblr, sans toutefois créer ce répertoire.
Semer
Prérequis
Pour installer Scrumblr, il nous faudra récupérer la dernière
version du code source. Pour cela, il est possible de
télécharger l’archive correspondante ou d’utiliser git. Nous
privilégierons ce dernier, car cela nous permettra de gérer
plus aisément les mises à jour. Pour installer git, rien de
plus simple :
sudo apt-get install git
Scrumblr
Clonons le code source de scrumblr en lançant la commande
suivante :
cd /var/www/
sudo git clone https://github.com/aliasaria/scrumblr.git
sudo chown scrumblr: -R /var/www/scrumblr
Ensuite, nous allons lancer l’installation des dépendances :
cd /var/www/scrumblr
sudo su scrumblr -s /bin/bash
npm install
exit
Framasky a codé quelques fonctionnalités plutôt pratiques :
un système d’import/export
le support du markdown
un système de révisions : créeez un point de révision,
exportez-le et réimportez-le pour y revenir
Pour profiter de ces fonctionnalités (qui ne sont pas encore
intégrées dans le dépôt originel (pull requests 95 et 96) :
cd /var/www/scrumblr
sudo su scrumblr -s /bin/bash
git remote add fork https://github.com/ldidry/scrumblr/
git fetch fork
git pull fork master
Arroser
Lancer Scrumblr
Scrumblr est maintenant prêt à être lancé avec node server.js
--port 4242 ! Mais pour ne pas avoir laisser un terminal
ouvert, il faut créer un service systemd. Créez le fichier
/etc/systemd/system/scrumblr.service :
[Unit]
Description=Scrumblr service
Documentation=https://github.com/aliasaria/scrumblr/
Requires=network.target
Requires=redis-server.service
After=network.target
After=redis-server.service
[Service]
Type=simple
User=scrumblr
WorkingDirectory=/var/www/scrumblr
ExecStart=/usr/bin/node server.js --port 4242
[Install]
WantedBy=multi-user.target
Bien sûr, choisissez le port que vous voulez, pourvu qu’il
soit supérieur à 1024 et non utilisé (vérifiez cela avec sudo
lsof -i :4242)
Ensuite, pour activer et lancer Scrumblr :
sudo systemctl daemon-reload
sudo systemctl enable scrumblr.service
sudo systemctl start scrumblr.service
Procéder aux mises à jour de Scrumblr
Notre Scrumblr est sorti de terre et se porte bien mais
comment le faire durer ? Voyons cela : utilisons git pour
récupérer la dernière version du logiciel :
cd /var/www/scrumblr
sudo su scrumblr -s /bin/bash
git pull
npm install
exit
sudo systemctl restart scrumblr.service
Rien de plus simple !
Regarder pousser
Mise en place d’un proxy inverse
Scrumblr est capable de fonctionner seul sur un port standard,
mais il est possible que nous ne dédiions pas notre machine à
ce service et que nous ayons d’autres applications Web à lui
adjoindre. Il peut dans ce cas être intéressant d’utiliser un
serveur frontal qui jouera le rôle de proxy inverse vers
Scrumblr. Pour cet exemple, nous choisissons d’employer Nginx
et un domaine ou sous-domaine dédié à l’instance Scrumblr.
Créons le fichier /etc/nginx/sites-available/scrumblr, par
exemple avec nano : sudo nano /etc/nginx/sitesavailable/scrumblr. À l’intérieur, nous optons pour la
configuration suivante :
upstream scrumblr {
server 127.0.0.1:4242;
}
server {
listen 80;
listen [::]:80;
server_name scrumblr.exemple.org;
access_log
/var/log/nginx/scrumblr.exemple.org.access.log;
error_log
/var/log/nginx/scrumblr.exemple.org.error.log;
index index.html;
root /var/www/html/;
location / {
proxy_set_header
Host $host;
proxy_pass http://framemo;
proxy_redirect
http://scrumblr
http://scrumblr.exemple.org;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}
Quelques explications :
Le port 80 est le port standard pour le Web (protocole
HTTP). Libre à vous de configurer un accès chiffré ;
Le server_name est le nom de domaine ou sous-domaine sur
lequel nous souhaitons que notre instance Scrumblr soit
accessible ;
Les *_log permettent d’isoler la journalisation des
accès et éventuelles erreurs de Nginx vers Scrumblr dans
des fichiers spécifiques ;
Tout le trafic sur ce domaine est redirigé vers
l’adresse locale, sur le port 4242 (que nous avons
choisi dans le service systemd).
Enfin, le dernier bloc permet de passer les requêtes
vers Scrumblr.
Nous allons ensuite activer cette configuration en créant un
lien symbolique vers la configuration active :
sudo
ln
-s
/etc/nginx/sites-available/scrumblr
/etc/nginx/sites-enabled
Relançons nginx de manière à ce qu’il prenne en compte le
nouveau fichier de configuration :
sudo nginx -t && sudo nginx -s reload
(nginx -t permet de vérifier que la configuration de Nginx est
valide avant de le relancer)
Installation de Minetest
Description
Minetest est un logiciel libre distribué sous LGPL v2.1+. Il
s’agit d’un jeu de type bac-à-sable en monde ouvert, inspiré
de InfiniMiner, Minecraft, et d’autres semblables.
Minetest est très facilement modulable. Il peut ainsi servir
des objectifs totalement différents, selon les mods qu’on y
installe. Une installation pourra servir comme jeu de ferme
entre amis, une autre installation comme d’un jeu avec des
monstres à battre, une autre installation comme d’un support
éducatif et encore plein d’autres. C’est le support éducatif
qui a intéressé Framasoft.
Ce guide est prévu pour Debian Stable. À l’heure où nous
écrivons ces mots, il s’agit de Debian 8.5 Jessie. Nous
partons du principe que vous venez d’installer le système et
que celui-ci est à jour.
Nourrir la terre
Utilisateur dédié
De manière à mieux isoler l’application, nous allons créer un
utilisateur dédié à Minetest, du même nom que le logiciel :
useradd -mU minetest
Cette commande crée l’utilisateur minetest ainsi qu’un groupe
du même nom. Il lui assigne comme répertoire personnel
/home/minetest, que minetest utilisera pour stocker ses
données (monde, mods, textures, données utilisateurs…).
Nous allons aussi créer quelques dossiers qui nous serviront
par la suite pour installer les mods et les textures.
mkdir
-p
/home/minetest/.minetest/textures
/home/minetest/.minetest/worlds
chown -R minetest: /home/minetest/.minetest/
Semer
Minetest
Il suffit d’installer minetest-server, de préférence depuis
les dépôts jessie-backports pour avoir la dernière version
disponible :
echo "deb http://ftp.debian.org/debian jessie-backports main"
> /etc/apt/sources.list.d/backports.list
apt-get update
apt-get install minetest-server -t jessie-backports
Précision sur l’ouverture des ports : le port dédié à Minetest
habituellement est le port 30000 en udp (mais vous pouvez
choisir un autre port comme 30001)
Arroser
Installer les mods
Téléchargez notre pack de texture, notre mod et notre exemple
de configuration
cd /home/minetest
wget
https://framinetest.org/dl/worldmods.tar.gz
https://framinetest.org/dl/textures.tar.gz
https://framinetest.org/dl/minetest.conf
Décompressez-les aux endroits idoines
cd .minetest/textures
tar xvf /home/minetest/textures.tar.gz
cd ../worlds
# Créez un dossier avec un nom qui vous convient, exemple
`FraminetestEdu`
mkdir FraminetestEdu
cd FraminetestEdu
tar xvf /home/minetest/worldmods.tar.gz
Liste des mods
Voici la listes des mods inclus dans notre pack spécial «
éducation » :
animals_modpack-2.5.0
minetest-mod-mesecons-master
plastique
biome_lib-master
minetest-mods-homedecor
quartz
car_f1
moreblocks-master
streets-1.5
farming_plus
moreores-master
technic-master
gloopblocks-master
moretrees-master
torches
hud_hunger
nether
unified_inventory
industry_pack
pipeworks-master
minetest-3d_armor-master
plantlife_modpack-master
Configurer Minetest
Éditez la configuration selon vos préférences
vi minetest.conf
Changer le propriétaire
Comme jusque là, on utilisait l’utilisateur root pour
travailler, il est important de rendre à minetest ce qui est à
minetest
chown -R minetest: /home/minetest
Et pour que nous puissions utiliser le dossier de log du
système
chown -R minetest /var/log/minetest
Pour démarrer le serveur sur un monde spécifique, il suffit de
faire :
minetestserver
worldname xxx
--config
/home/minetest/minetest.conf
--
ou simplement, si un monde par défaut est configuré dans le
minetest.conf :
minetestserver --config /home/minetest/minetest.conf
Attention, assurez-vous d’abord que le serveur minetest lancé
à l’installation du paquet soit coupé :
systemctl stop minetest-server
Regarder pousser
Créer un service pour Minetest
Un serveur minetest, c’est bien, mais c’est encore mieux si le
serveur se lance automatiquement au démarrage de la machine.
Tout d’abord, nous il faut couper et désactiver le serveur
minetest qui s’est lancé à l’installation du paquet :
systemctl stop minetest-server
systemctl disable minetest-server
Puis nous créons un service pour notre configuration :
vi /etc/systemd/system/minetest.service
Dont le contenu sera :
[Unit]
Description=Minetest multiplayer server minetest.conf server
config
Documentation=man:minetestserver(6)
After=network.target
RequiresMountsFor=/home/minetest
[Service]
Restart=on-failure
User=minetest
Group=minetest
ExecStart=/usr/lib/minetest/minetestserver
/home/minetest/minetest.conf
/var/log/minetest/minetest.log
--config
--logfile
[Install]
WantedBy=multi-user.target
On l’active pour qu’il se lance au démarrage et on le lance :
systemctl daemon-reload
systemctl enable minetest
systemctl start minetest
Vous
avez
la
possibilité
de
programmer
des
horaires
d’ouverture/fermeture via des tâches cron pour, par exemple,
n’allumer le service que pendant les heures de cours.
Autres serveurs
Vous pouvez également trouver votre bonheur dans l’un des
serveurs publics
Alternative
Pour des groupes de 4-8 élèves
Il existe enfin une dernière possibilité, très simple à mettre
en place, mais limité à quelques élèves : utiliser le client
Minetest en mode graphique (comme si vous alliez jouer), mais
en choisissant l’onglet « Server » (au lieu de client). Une
fois le serveur démarré de cette manière, il ne vous reste
plus qu’à :
Vérifier que votre parefeu autorise le port 30000/UDP en
entrée ;
Vérifier que tous les joueurs sont sur le même réseau
que vous ;
Distribuer votre adresse IP (celle de l’ordinateur
faisant office de serveur). (Sous Windows, la commande
ipconfig dans une invite de commande permet de l’avoir.
Sur GNU/Linux, on utilisera la commande ip addr show.
Merci à Powi et Sangokuss pour la rédaction de ce tutoriel !
Installation
Mattermost
de
Gitlab
et
Introduction
On ne présente plus Gitlab aux barbus qui font du
développement… l’alternative la plus populaire à github pour
gérer le versionnement de son code via un site web, que nous
utilisons pour… Framagit (surprise !).
Mattermost est un logiciel de chat en groupe, alternative au
service privateur Slack. Voyez-le comme une alternative plus
moderne à IRC : on peut y créer des groupes de discussion
facilement, en y incluant des médias. Du coup, nous nous
fondons sur celui-ci pour offrir Framateam.
Depuis
Août
2015
et
la
version
7.22,
Gitlab
intègre
directement Mattermost dans ses versions. Nous allons pouvoir
faire d’une pierre deux coups !
Si gitlab et mattermost vont désormais de pair, il est
toujours possible d’installer Mattermost tout seul, en stand
alone comme on dit dans le jargon. N’hésitez pas à jeter un
oeil à la documentation de Mattermost pour cela !
Prérequis
La machine utilisée pour ce tutoriel tourne sous Linux Debian
Jessie. C’est tout ! Pas de serveur web ni de base de données,
Gitlab embarque ce dont il a besoin avec son package.
La version de Gitlab installée ici est la version omnibus
(c’est à dire qu’elle inclut tous les packages dont elle
pourrait avoir besoin), d’où le peu de dépendances.
En option, vous pourriez avoir besoin :
d’un
nom
de
domaine
correctement
configuré
pour
rediriger vers votre serveur
d’un serveur mail opérationnel pour les notifications de
messages
Prenez aussi le temps de regarder les prérequis hardware de
gitlab : c’est un logiciel qui peut être un peu gourmand
(selon la volumétrie d’utilisateurs que vous aurez), ils
recommandent un minimum de deux cœurs et 2 Go de mémoire vive.
Il est possible mais pas vraiment conseillé de l’installer sur
une « petite » machine comme un Raspberry Pi pour une
utilisation au quotidien!
Installation
1 – Préparer la terre
Commençons par installer l’indispensable (certains packages
devraient être installés par défaut, mais rien ne coûte de
vérifier) :
sudo apt-get install curl openssh-server ca-certificates
Ensuite, configuration des sources :
curl
-sS
https://packages.gitlab.com/install/repositories/gitlab/gitlab
-ce/script.deb.sh > script.deb.sh
Ne pas hésiter à ouvrir le fichier script.deb.sh pour savoir
ce qu’il fait (en plus il est bien commenté !)
sudo bash script.deb.sh
Vous devriez avoir une réponse de ce genre:
Detected operating system as debian/jessie.
Checking for curl...
Detected curl...
Running apt-get update... done.
Installing debian-archive-keyring which is needed for
installing
apt-transport-https on many Debian systems.
Installing apt-transport-https... done.
Installing /etc/apt/sources.list.d/gitlab_gitlabce.list...done.
Importing packagecloud gpg key... done.
Running apt-get update... done.
The repository is setup! You can now install packages.
2 – Semer
Passons aux choses sérieuses avec l’installation :
sudo apt-get install gitlab-ce
L’installation nous conseillera de lancer un sudo gitlab-ctl
reconfigure mais faisons quelques ajustements avant cela, que
ce soit pour Gitlab ou pour Mattermost.
Configuration de Gitlab
sudo vi /etc/gitlab/gitlab.rb
Les options à contrôler/décommenter sont les suivantes dans
notre cas:
external_url 'gitlab.example.org' : l’URL du gitlab
(vous noterez qu’il n’y a pas de ‘=’ au contraire des
autres paramètres)
gitlab_rails['gitlab_email_enabled'] : pour les mails de
notification
gitlab_rails['gitlab_email_from'] : l’adresse de
provenance des mails
gitlab_rails['gitlab_email_display_name'] : un petit nom
sympa « Gitlab de XXX »
gitlab_rails['gitlab_email_reply_to'] : une adresse de
réponse pour les mails (champ reply to: nous avons mis
une adresse noreply ici car nous ne gérons pas les
réponses par mail)
gitlab_rails['gitlab_default_theme'] : choisissez ici le
thème par défaut. Framasoft a fait le choix 1 (contre 2
par défaut)
gitlab_rails['gitlab_default_projects_features_merge_req
uests'] : pour activer (ou non) par défaut les merge
request par défaut sur les projets
gitlab_rails['gitlab_default_projects_features_wiki'] :
pour activer (ou non) par défaut les wikis
gitlab_rails['gitlab_default_projects_features_snippets'
] : pour activer (ou non) par défaut les snippets (comme
les gists de github)
gitlab_rails['incoming_email_enabled'] : permettre aux
utilisateurs de répondre aux tickets et merge requests
par mail. Framasoft l’a désactivé. Une documentation ici
pour le mettre en place
Authentification LDAP, pour utiliser un LDAP pour se
loguer :
gitlab_rails['ldap_enabled'] = true
gitlab_rails['ldap_servers'] = YAML.load <<-'EOS' #
remember to close this block with 'EOS' below
main: # 'main' is the GitLab 'provider ID' of this
LDAP server
label: 'LDAP'
host: 'ldap.example.org'
port: 636
uid: 'uid'
method: 'ssl' # "tls" or "ssl" or "plain"
bind_dn:
'uid=ldapaccess,ou=users,dc=example,dc=org'
password: 'password'
active_directory: false
allow_username_or_email_login: true
block_auto_created_users: false
base: 'ou=users,dc=example,dc=org'
user_filter: '(uid!=ldapaccess)'
attributes:
username: ['uid', 'userid', 'sAMAccountName']
email:
['mail', 'email', 'userPrincipalName']
name:
'cn'
first_name: 'givenName'
last_name: 'sn'
EOS
Permettre l’authentification via Oauth (créer des
« applications » sur github et gitlab pour avoir les
app_id et app_secret) :
gitlab_rails['omniauth_enabled'] = true
gitlab_rails['omniauth_allow_single_sign_on'] = true
(**['saml']** ???)
gitlab_rails['omniauth_block_auto_created_users']
=
false
gitlab_rails['omniauth_auto_link_ldap_user'] = false
gitlab_rails['omniauth_providers'] = [
{
"name" => "github",
"label" => "GitHub",
"app_id" => "",
"app_secret" => "",
"args" => { "scope" => "user:email" }
},{
"name" => "gitlab",
"label" => "GitLab.com",
"app_id" => "",
"app_secret" => "",
"args" => { "scope" => "api" }
}
]
gitlab_rails['backup_keep_time'] : durée en secondes de
rétention des sauvegardes que Gitlab fait tous les jours
(dépôts + dump SQL) Attention, cela peut vite prendre de
la place ! Comme c’est notre cas chez Framasoft, nous
avons un montage ssh sur /opt/backup, vers lequel nous
envoyons ces sauvegardes une fois qu’elles sont faites :
gitlab_rails['backup_upload_connection'] = {
:provider => 'Local',
:local_root => '/opt/backup/'
}
gitlab_rails['backup_upload_remote_directory'] = '.' #
ou '/gitlab' si vous voulez les mettre dans
'/opt/backup/gitlab'
Cependant, il faut encore supprimer les anciennes
sauvegardes régulièrement. Nous faisons ça avec un cron
(suppression des sauvegardes qui datent de plus de 15
jours) : 17 8 * * * find /opt/backup -mtime "+15" delete
Pour finir :
gitlab_rails['extra_piwik_url']
=
'piwik.example.org' : pour les stats piwik, l’hôte
du piwik
gitlab_rails['extra_piwik_site_id'] : l’id piwik
de votre gitlab
nginx['redirect_http_to_https'] : rediriger toutes
les requêtes http vers la version https
nginx['ssl_certificate'] : le chemin absolu du
certificat (avec sa chaîne de certification)
nginx['ssl_certificate_key'] : le chemin absolu de
la clé du certificat
nginx['ssl_dhparam'] : il est toujours bon pour la
sécurité de générer un fichier dhparam : openssl
dhparam -out /etc/gitlab/dhparams.pem 4096
nginx['custom_nginx_config']
=
"include
/var/opt/gitlab/nginx/conf/conf.d/*.conf;" : Juste
pour avoir un dossier dans lequel ajouter de la
configuration Nginx sans avoir à modifier la
configuration gitlab. C’est très pratique, comme
on le verra plus loin. Ne pas oublier de le créer
s’il n’existe pas déjà via un mkdir -p
/var/opt/gitlab/nginx/conf/conf.d/
Configuration de Mattermost
La configuration est très similaire à celle que nous venons de
faire sur Gitlab. Dans le même fichier de configuration
/etc/gitlab/gitlab.rb :
mattermost_external_url
'https://mattermost.example.org' : l’URL de Mattermost
(comme pour gitlab, pas de ‘=’ ici)
mattermost['enable'] = true : pour activer mattermost
mattermost['service_use_ssl'] = true : httpS, c’est bien
!
mattermost['service_enable_incoming_webhooks'] = true :
pour permettre d’envoyer des messages à mattermost
depuis gitlab (ou n’importe quel autre outil, tant que
le message est bien formé)
mattermost['service_allow_cors_from']
=
"gitlab.example.org" : pour autoriser les requêtes
provenant d’autres domaines. Mettre '*' pour tout
autoriser, laisser vide ('') pour désactiver
mattermost['service_enable_commands'] = true : autoriser
les utilisateurs à créer des slash commands (voir dans
les bonus, en bas de cet article)
mattermost['team_site_name'] = "Mon super mattermost" :
Le petit nom de votre mattermost. Chez nous, c’est
« Framateam »
mattermost['team_enable_team_listing'] = true :
autoriser les équipes à se placer (volontairement, en
opt-in) dans l’annuaire des équipes, permettant à
quiconque de choisir une équipe existante depuis la page
d’accueil
Pour permettre l’authentification avec les comptes de
votre Gitlab :
mattermost['gitlab_enable'] = true
mattermost['gitlab_secret']
et
mattermost['gitlab_id'] : pour obtenir le
gitlab_secret et le gitlab_id, créez une
application dans la partie admin de gitlab, avec
comme
«
Redirect
URL
»
https://mattermost.example.org/signup/gitlab/compl
ete
et
https://mattermost.example.org/login/gitlab/comple
te (une URL par ligne)
mattermost['gitlab_auth_endpoint']
"https://gitlab.example.org/oauth/authorize"
=
mattermost['gitlab_token_endpoint']
"https://gitlab.example.org/oauth/token"
=
mattermost['gitlab_user_api_endpoint']
"https://gitlab.example.org/api/v3/user"
=
Et pour configurer le serveur mail (comme pour gitlab) :
mattermost['email_enable_sign_up_with_email']
=
true
mattermost['email_enable_sign_in_with_email']
true
mattermost['email_enable_sign_in_with_username']
true
mattermost['email_send_email_notifications']
true
mattermost['email_require_email_verification']
true
mattermost['email_smtp_username']
"[email protected]"
mattermost['email_smtp_password'] = "password"
=
=
=
=
=
mattermost['email_smtp_server']
=
"mail.mattermost.org"
mattermost['email_smtp_port'] = "465"
mattermost['email_connection_security'] = "TLS"
mattermost['email_feedback_name'] = "Notification
Mattermost"
mattermost['email_feedback_email']
=
"[email protected]"
mattermost['support_email'] = "[email protected]" :
l’adresse e-mail du support
mattermost['privacy_show_email_address'] = false : les
adresses e-mail des inscrits ne seront pas affichées
mattermost['privacy_show_full_name'] = false : pareil
pour leur vrai nom. Seuls les pseudos seront affichés
mattermost_nginx['enable'] = true : c’est mieux si votre
mattermost est accessible par le web
mattermost_nginx['redirect_http_to_https']
=
true
:
httpS. Toujours httpS !
mattermost_nginx['ssl_certificate'] : le chemin absolu
du certificat (avec sa chaîne de certification)
mattermost_nginx['ssl_certificate_key'] : le
chemin
absolu de la clé du certificat
mattermost_nginx['ssl_dhparam'] : même remarque que pour
gitlab ci-dessus
Et on termine l’installation avec :
sudo gitlab-ctl reconfigure
Ouf ! Ça en fait des choses à configurer.
3 – Arroser
Un petit mot à propos de gitlab-ctl
Gitlab vient avec son Nginx, son PostgreSQL, etc. On ne peut
pas les relancer avec service nginx restart.
À la place on utilise gitlab-ctl restart nginx. Lancez gitlabctl help pour voir toutes les options.
Pensez d’ailleurs à ne pas mettre en concurrence (sur le même
port) le nginx de gitlab avec un éventuel apache/nginx
installé sur votre machine ! (Votre serviteur s’est retrouvé
avec un Gitlab « qui ne marchait pas » avec une erreur 404,
avant de comprendre que le nginx stand-alone était démarré et
prenait la requête en premier…
)
Comme gitlab vient avec son PostgreSQL, pour accéder à la base
de données, il faut faire su gitlab-psql -s /bin/bash
/opt/gitlab/embedded/bin/psql -h /var/opt/gitlab/postgresql/
gitlabhq_production ou plus simplement gitlab-rails dbconsole
(plus long pour arriver à la console, mais plus simple à
retenir)
Mettre à jour Gitlab et Mattermost
Dans la première partie, nous avons récupéré un script qui
ajoutait dans les sources de paquets celui de gitlab. Il est
donc très simple de mettre à jour gitlab, que ce soit avec
tous les paquets en même temps (sudo apt-get upgrade) ou ce
paquet spécifique (sudo apt-get install --only-upgrade gitlabce).
4 – Pailler
IPv6
Parce que gitlab, c’est bien, mais gitlab en IPv6, c’est
mieux ! Mais Gitlab ne prend pas en compte IPv6 par défaut.
Plutôt que de modifier les fichiers de configuration créés par
gitlab, nous allons les dupliquer et les adapter. De cette
façon, nous n’aurons pas à remettre nos modifications à chaque
mise à jour de gitlab (ce qui arrive plusieurs fois par mois).
En revanche, il faudra vérifier à chaque mise à jour si les
fichiers de configuration de gitlab ont été modifiés, pour
reporter les éventuelles modifications sur nos fichiers IPv6.
cd /var/opt/gitlab/nginx/conf/
cp gitlab-http.conf gitlab-mattermost-http.conf conf.d/
cd conf.d
vi gitlab-http.conf gitlab-mattermost-http.conf
Là, remplacez les lignes suivantes :
listen *:80; par listen [::]:80;
listen *:443 ssl http2; par listen [::]:443 ssl http2;
…Et supprimez les blocs suivants :
upstream gitlab-workhorse dans le fichier gitlabhttp.conf
upstream gitlab_mattermost et map $http_upgrade
$connection_upgrade dans gitlab-mattermost-http.conf
Ensuite, on relance nginx avec un petit gitlab-ctl restart
nginx.
Synchronisation
(Mirroring)
avec
des
projets
github
Il suffit d’installer WebHooker, qui vous permettra de faire
une copie miroir de vos projets Gitlab sur votre compte
Github.
Installation
Le wiki de ce projet étant déjà bien documenté (et en
français !), nous passerons rapidement sur l’installation :
Dépendances nécessaires
:
sudo su
apt-get install git build-essential
cpan Carton
(Suivre les recommandations par défaut lors de l’installation
de carton)
Attention à ne pas oublier la majuscule à `Carton` lors de la
commande cpan ! (sinon il ne trouvera pas le package)
Installation de Web Hooker :
sudo su
cd /opt/
git clone https://git.framasoft.org/luc/webhooker.git
web_hooker
cd web_hooker
carton install
cp web_hooker.conf.template web_hooker.conf
Éditez le fichier web_hooker.conf afin qu’il corresponde à
votre configuration : repo_dir, authorized, et l’adresse
d’écoute et user dans la partie hyptnotoad (il est court et
bien commenté, c’est assez simple de s’y retrouver).
Vous devrez y renseigner un utilisateur et mot de passe GitHub
pour que WebHooker puisse pousser les modifications en son
nom.
Mention spéciale pour l’option authorized, en particulier si
vous comptez ouvrir votre Gitlab à d’autres utilisateurs :
WebHooker donne le droit à tous les utilisateurs du Gitlab de
pousser des modifications au nom de l’utilisateur configuré
(si ce dernier a les droits de le faire bien sûr). Ce qui
n’est peut-être pas recommandé si vous avez d’autres projets
sur GitHub que vous souhaiteriez ne pas modifier. L’option
authorized est là pour ca: Il s’agit d’une liste blanche des
projets sur lesquels WebHooker peut pousser des modifications.
Pensez à y jeter un oeil et le configurer !
Reste ensuite à lancer WebHooker au démarrage (nous utilisons
systemd ici, mais une configuration existe pour initV dans la
documentation de WebHooker) :
sudo cp /opt/web_hooker/utilities/web_hooker.service
/etc/systemd/system
Éditer /etc/systemd/system/web_hooker.service fraîchement
copié pour l’adapter – en particulier à votre répertoire
d’installation
dans
/opt/web_hooker/).
WorkingDirectory
(pour
nous,
N’oubliez pas de vérifier les droits de votre dossier
d’installation, pour que le service puisse le démarrer!
(utilisateur git par défaut)
Et pour finir:
sudo su
systemctl daemon-reload
systemctl enable web_hooker.service
systemctl start web_hooker.service
Utilisation
C’est installé et en cours d’exécution, tout ce que vous avez
à faire maintenant est d’ajouter dans gitlab un web hook à
votre projet avec une URL de la forme suivante :
http://127.0.0.1:4242/<github_username>/<github_repo>
Recherches sur giphy depuis Mattermost
Il suffit d’installer Giphy Mat Hooker puis de configurer des
slash commands (ou commandes slash, commencant par le
caractère /) dans un chat Mattermost pour chercher et afficher
des gifs depuis http://giphy.com/.
Installation
Pour les mêmes raisons que webhooker, nous passerons
rapidement sur l’installation. N’hésitez pas à jeter un oeil à
la documentation de Giphy Mat Hooker.
Les dépendances sont d’ailleurs pratiquement les mêmes :
sudo su
apt-get install git build-essential libssl-dev
cpan Carton
Attention à ne pas oublier la majuscule à `Carton` lors de la
commande cpan ! (sinon il ne trouvera pas le package)
cd /var/www/
git
clone
https://git.framasoft.org/framasoft/giphymathooker.git
cd giphymathooker
carton install
cp giphy_mat_hooker.conf.template giphy_mat_hooker.conf
chown -R www-data:www-data /var/www/giphymathooker/
Le fichier de configuration giphy_mat_hooker.conf fraîchement
copié contient les explications nécessaires pour que vous
l’adaptiez à votre besoin, comme webhooker (ça se voit tant
que ça que le développeur est le même?
). En particulier,
jetez un oeil à la clef d’API Giphy si vous souhaitez un usage
en production.
Au besoin, un template de configuration pour nginx existe dans
le sous dossier utilities si vous souhaitez mettre Giphy Mat
Hooker derrière un reverse proxy.
Plus qu’à activer le service au démarrage de la machine :
sudo su
cp utilities/giphymathooker.service /etc/systemd/system/
vi /etc/systemd/system/giphymathooker.service
systemctl daemon-reload
systemctl enable giphymathooker.service
systemctl start giphymathooker.service
Utilisation dans Mattermost
Jetez tout d’abord un œil à la documentation Mattermost sur
les slash commands.
Il faut créer avec un compte administrateur la slash command.
Clic sur le nom d’équipe (coin haut gauche), puis
« Integrations » et « Slash commands »
Créez ensuite votre commande slash en renseignant l’URL de
l’installation (par exemple https://giphy.example.org), puis
laissez par défaut la méthode POST (cela n’a pas d’importance,
GMH est capable de répondre aux deux méthodes). Une fois
validé, profitez pour noter le jeton (token) attribué par
Mattermost.
Retournez
dans
le
fichier
de
configuration
giphy_mat_hooker.conf et renseignez le jeton sus-nommé. Si
vous ne le renseignez pas, n’importe quel service sera capable
de le solliciter s’il fournit les paramètres de Mattermost.
Vous pouvez désormais chercher des gifs sur Giphy avec la
commande /gif ma recherche (si vous avez choisi gif comme mot
clef pour la commande slash).
Un très grand merci à Framasky pour son aide et ces heures de
debug passées ensemble ! Vous avez ce tutoriel en grande
partie grâce à lui
Installation de Wallabag
Wallabag est une application de lecture différée : une page
web vous intéresse mais vous ne pouvez la lire à l’instant ?
Sauvegardez-là dans votre Wallabag pour la lire plus tard (sur
navigateur, application mobile, ou liseuse).
Framasoft propose une instance de Wallabag nommée bien
entendu… Framabag
Pour une présentation plus complète et en
images, n’hésitez pas à jeter un œil à notre présentation de
Wallabag.
N’hésitez pas aussi à consulter la documentation officielle de
Wallabag, riche en informations !
Deux installations sont possibles : sur un serveur dédié, ou
sur un hébergement mutualisé. Cependant, l’installation en
mutualisé n’est pas celle que recommandent les développeurs et
elle ne sera pas traitée dans ce tutoriel (votre serviteur n’a
pas d’hébergement de test compatible). Ils fournissent
néanmoins un paquet contenant toutes les dépendances
facilitant le déploiement pour ceux qui le souhaitent.
Prérequis
La machine utilisée pour ce tutoriel est la suivante :
Linux Debian Jessie
Serveur web Nginx installé
PHP 5.5 minimum (des configurations récentes avec PHP 7
fonctionnent aussi)
En option, vous pourriez avoir besoin :
d’un
nom
de
domaine
correctement
configuré
pour
rediriger vers votre serveur
d’un serveur mail opérationnel pour confirmer les
nouveaux comptes et la double authentification
Note : pour installer PHP sur Debian avec Nginx, n’installez
pas le paquet php5 qui a pour dépendance Apache2, mais
préférez le paquet php5-fpm (qui sera nécessaire pour la
communication entre PHP et Nginx).
Installation
1 – Préparer la terre
Ma chère Maïté, pour préparer la recette du Wallabag, il nous
faut quelques ustensiles !
Tout d’abord, nous allons avoir besoin de git pour récupérer
les sources, et de curl qui est utilisé en sous-main par
Wallabag :
sudo apt-get install git curl
Wallabag utilise aussi PHP pour fonctionner avec moult
modules. Rassurez-vous, la plupart sont fournis par défaut !
Pour ceux qui manqueraient potentiellement :
sudo apt-get install php5-curl php5-gd php5-sqlite php5-tidy
Pour vérifier que tout ce qu’il faut est installé, un petit
php -m vous indiquera quels sont les modules utilisés par PHP
(en ligne de commande – ce n’est pas forcément ce qui sera
utilisé par le serveur web, mais c’est un moyen simple et
rapide de voir si le module est installé).
Vous pouvez aussi vérifier que les modules sont activés pour
php-fpm, en vérifiant quels sont les modules activés dans
/etc/php5/mods-available/. Si vous voyez une ligne du genre
extension=tidy.so sans point-virgule devant, c’est activé.
Vous devez retrouver ces éléments dans la réponse de php -m :
php-session
php-ctype
php-dom
php-hash
php-simplexml
php-json
php-gd
php-mbstring
php-xml
php-tidy
php-iconv
php-curl
php-gettext
php-tokenizer
Afin de se connecter à une base de données, Wallabag utilise
un des modules PDO. Vous aurez donc besoin d’au moins une
extension et d’un système de bases de données au choix parmi :
pdo_mysql
pdo_sqlite
pdo_pgsql
Pour la suite, nous utiliseront sqlite, qui est plus facile à
configurer.
Enfin,
pour
gérer
les
dépendances
PHP
et
construire
l’application, il nous faudra Composer :
curl -s http://getcomposer.org/installer | php
sudo mv composer.phar /bin/composer
sudo chown root:root /bin/composer
(respectivement : on récupère l’installeur, on copie dans les
exécutables du système et on vérifie que les droits sont bien
d’équerre)
2 – Semer
Maintenant que tout est prêt, la météo est bonne, rentrons
dans le vif du sujet !
On se place dans le répertoire de Nginx (dans notre
installation, /var/www/html) et on récupère les sources de
Wallabag :
cd /var/www/html
sudo git clone https://github.com/wallabag/wallabag.git
Une fois que tout est téléchargé, on rentre dans le dossier
fraîchement créé, et on prépare l’installation avec Composer :
cd wallabag
SYMFONY_ENV=prod composer install --no-dev -o --prefer-dist
Au lancement de la dernière commande ci-dessus, Composer va
préparer le package Wallabag pour qu’il soit utilisable, et
vous posera des questions sur la configuration à générer.
Laissez les options par défaut si vous ne savez pas quoi
mettre.
Quelques recommandations tout de même :
dans le cas de SQLite, bien mettre l’utilisateur
database_user comme celui de nginx (ici www-data), sinon
il lui sera difficile d’y accéder.
il est préférable (mais pas indispensable) de renseigner
un serveur mail fonctionnel, car il peut servir pour
créer et vérifier les comptes, ainsi que pour la double
authentification (twofactor).
À titre d’exemple, la configuration utilisée dans le cadre de
ce tutoriel :
Creating the "app/config/parameters.yml" file
Some parameters are missing. Please provide them.
database_driver (pdo_sqlite):
database_host (127.0.0.1):
database_port (null):
database_name (symfony):
database_user (root): www-data
database_password (null):
database_path
('%kernel.root_dir%/../data/db/wallabag.sqlite'):
database_table_prefix (wallabag_):
mailer_transport (smtp):
mailer_host (127.0.0.1):
mailer_user (null):
mailer_password (null):
locale (en): fr
secret (ovmpmAWXRCabNlMgzlzFXDYmCFfzGv):
twofactor_auth (true): false
twofactor_sender ([email protected]):
fosuser_confirmation (true):
from_email ([email protected]):
Vous voulez changer un paramètre plus tard ? Tant pis, il
faudra tout réinstaller !
Blague à part, ces paramètres
peuvent se retrouver dans le dossier d’installation de
Wallabag,
plus
précisément
dans
le
fichier
app/config/parameters.yml.
Une dernière commande pour finaliser l’installation du package
préparé précédemment :
php bin/console wallabag:install --env=prod
La réponse attendue :
Installing Wallabag...
Step 1 of 5. Checking system requirements.
+-----------------+--------+----------------+
| Checked
| Status | Recommendation |
+-----------------+--------+----------------+
| PDO Driver
| OK!
|
|
| curl_exec
| OK!
|
|
| curl_multi_init | OK!
|
|
+-----------------+--------+----------------+
Success! Your system can run Wallabag properly.
Step 2 of 5. Setting up database.
Creating database and schema, clearing the cache
Step 3 of 5. Administration setup.
Would you like to create a new admin user (recommended) ?
(Y/n)Y
Username (default: wallabag) :
Password (default: wallabag) : sup3rm0td3p4ssed3r0x0r
Email:
Step 4 of 5. Config setup.
Step 5 of 5. Installing assets.
Wallabag has been successfully installed.
Just execute `php bin/console server:run --env=prod` for using
wallabag: http://localhost:8000
(n’oubliez pas de renseigner – et mémoriser – le compte admin
comme demandé dans l’étape 3)
Enfin pour finaliser et faire bonne mesure, on s’assure que le
dossier wallabag fraîchement préparé appartient bien au même
utilisateur que Nginx :
sudo chown -R www-data:www-data /var/www/html/wallabag/
Voilà, Wallabag est installé ! Vous pouvez le tester avec un
serveur local en lançant php bin/console server:run --env=prod
et en allant voir sur http://[ip-de-votre-serveur]:8000 (pour
tester uniquement !).
3 – Arroser
La plupart d’entre vous voudront sûrement le mettre derrière
un serveur web (fortement recommandé si ce n’est pas un simple
serveur de test !). Dans notre configuration, il s’agit de
Nginx. Les fichiers de configuration des sites se trouvent
dans /etc/nginx/sites-available, nous allons donc créer la
configuration à cet endroit :
cd /etc/nginx/sites-available/
nano wallabag.mydomain.tld
Reste à remplir ce fichier :
server {
server_name default_server;
root /var/www/html/wallabag/web;
location / {
# try to serve file directly, fallback to app.php
try_files $uri /app.php$is_args$args;
}
location ~ ^/app\.php(/|$) {
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_split_path_info ^(.+\.php)(/.*)$;
include fastcgi_params;
fastcgi_param
SCRIPT_FILENAME
$realpath_root$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT $realpath_root;
# Prevents URIs that include the front controller.
This will 404:
# http://domain.tld/app.php/some-path
# Remove the internal directive to allow URIs like
this
internal;
}
error_log /var/log/nginx/wallabag.error.log;
access_log /var/log/nginx/wallabag.access.log;
}
Notes :
Attention ! pour ceux qui ont l’habitude de configurer
avec un index.html/php à la racine, ici il faut pointer
vers le sous-dossier web et le fichier app.php.
Changez le server_name à votre sauce bien sûr, selon les
domaines et redirections DNS que vous préférez (nous
avons mis ici default_server car notre instance de test
n’avait pas besoin de plus)
Reste à activer cette configuration et redémarrer Nginx pour
qu’il la prenne en compte :
cd /etc/nginx/sites-enabled/
sudo ln -s ../sites-available/wallabag
sudo systemctl restart nginx
Plus qu’à aller sur l’adresse souhaitée (à défaut l’adresse IP
du serveur) et vous connecter avec le compte admin
précédemment créé.
Dans l’état actuel, si vous n’avez pas renseigné de serveur
mail, les utilisateurs ne pourront pas créer de compte par
eux-mêmes. Deux solutions possibles : intercepter le mail qui
ne s’enverra pas dans votre mailqueue (sudo mailq), ou créer
vous-même l’utilisateur via l’interface de l’admin :
Configuration > Créer un compte
4 – Pailler
Bloquer l’inscription spontanée
Il n’est pas possible de bloquer l’inscription de nouveaux
utilisateurs dans l’écran de login pour l’instant. Le problème
est connu des développeurs et sera bientôt intégré. Une
solution en attendant est de bloquer l’enregistrement via
Nginx en ajoutant dans le fichier :
location ^~ /register {
deny all;
return 403;
}
Mettre à jour wallabag
Il vous suffit de reprendre les dernières sources et de les
recompiler avec composer. Reprenez le chapitre « Semer » et
procédez à l’installation, en reprenant la base de données
existante (faites un backup à minima de votre base de données
avant ! Comme on dit de l’autre côté de la Manche, Better safe
than sorry
).
Installation de Loomio
Loomio est le logiciel de prise de décision collective que
nous proposons comme service en ligne sur Framavox.
Voici un tutoriel pour vous aider à l’installer sur votre
serveur. Il s’appuie sur la procédure officielle.
N’hésitez pas à poser des questions dans les commentaires. Si
vous êtes parvenu à l’installer, donnez-nous le lien vers
votre instance et dites-nous dans quelle mesure ce tutoriel
vous aura été utile
Informations
Dans la suite de ce tutoriel, les instructions seront données
pour un serveur dédié sous Ubuntu 14.04 en utilisant Docker.
Installation
1 – Préparer la terre
DNS
Tout d’abord, faites pointer votre-domaine.org sur votre
serveur auprès de votre registraire ainsi que le sous-domaine
faye.votre-domaine.org (il s’agit du service qui tourne en
arrière-plan pour envoyer les mails et notifications aux
utilisateurs).
Voici par exemple ce que nous avons mis pour framavox.org dans
notre zone DNS :
@ 3600 IN A 46.4.207.243
faye 3600 IN CNAME framavox.org.
@ 10800 IN MX 2 framavox.org.
Docker
Ensuite, connectez-vous en tant que root sur votre serveur,
installez Docker et Docker Compose.
wget -q https://get.docker.com/ -O install-docker.sh
# Vérifiez le contenu du script pour vous assurer qu'il ne
fait pas de bêtises sur votre système
sh install-docker.sh
wget
-O
/usr/local/bin/docker-compose
https://github.com/docker/compose/releases/download/1.6.2/dock
er-compose-`uname -s`-`uname -m`
chmod +x /usr/local/bin/docker-compose
2 – Semer
Depuis le dossier /root, téléchargez les fichiers du dépôt
officiel pour un déploiement en production.
cd /root
git clone https://github.com/loomio/loomio-deploy.git
cd loomio-deploy
Toutes les instructions suivantes s’effectueront depuis le
dossier /root/loomio-deploy.
Swap (facultatif)
Si votre serveur dispose de moins de 4GB de RAM, il est
recommandé de créer un fichier de swap.
./scripts/create_swapfile
Configuration
Créez ensuite les fichiers de configuration de Loomio.
./scripts/create_env votre-domaine.org [email protected]
Le script crée 2 fichiers env et faye_env qui seront utilisés
pour configurer les différents containers Docker :
nginx, le serveur web
letsencrypt, pour créer automatiquement les certificats
SSL et disposer d’un site en https
loomio, la partie visible par les navigateurs web
worker, faye et mailin qui traitent en arrière-plan les
requêtes pour l’envoi des courriels, des notifications
et autres interactions
db, le serveur de base de données (PostgreSQL)
Courriels
Modifiez le fichier env pour configurer l’envoi des courriels
avec un serveur SMTP.
SMTP_DOMAIN=votre-domaine.org
SMTP_SERVER=serveur.mail.org
SMTP_PORT=587
[email protected]
SMTP_PASSWORD=votre-mot-de-passe
Les messages seront envoyés avec l’adresse [email protected]. Pour permettre la bonne transmission des mails
lorsque les utilisateurs répondent à un courriel de
notification, nous avons dû adapter la configuration du
container mailin dans docker-compose.yml.
mailin:
image: loomio/mailin-docker
ports:
- "25:25"
links:
- loomio
environment:
- WEBHOOK_URL=https://votre-domaine.org/email_processor/
NB Si vous avez déjà un logiciel de mail sur votre serveur, il
n’aimera pas être dépossédé du port 25. Vous pouvez le couper
(service exim4 stop) et le désactiver (update-rc.d exim4
disable) ou le faire écouter sur un autre port
(/etc/default/exim4).
Tâches planifiées
Pour prévenir les utilisateurs de la fermeture imminente d’une
proposition, la clôturer ou encore envoyer un courriel
récapitulatif de l’activité de la veille, Loomio doit exécuter
certains processus périodiquement.
Pour cela, copiez le fichier crontab dans /etc/cron.d
mv ./crontab /etc/cron.d/loomio
Service
Pour disposer d’une commande d’arrêt/relance de Loomio ou pour
qu’il reste actif après un redémarrage du serveur, vous pouvez
créer un fichier /etc/init.d/loomio (à rendre exécutable)
contenant ceci :
#! /bin/sh
### BEGIN INIT INFO
# Provides:
# Required-Start:
# Required-Stop:
# Default-Start:
# Default-Stop:
# Short-Description:
### END INIT INFO
loomio
$remote_fs $syslog
$remote_fs $syslog
2 3 4 5
Loomio dockers services
set -e
umask 022
. /lib/lsb/init-functions
case "$1" in
start)
cd /root/loomio-deploy/
/usr/local/bin/docker-compose start
log_end_msg 0 || true
;;
stop)
cd /root/loomio-deploy/
/usr/local/bin/docker-compose stop
log_end_msg 0 || true
;;
logs)
cd /root/loomio-deploy/
/usr/local/bin/docker-compose logs
log_end_msg 0 || true
;;
restart)
cd /root/loomio-deploy/
/usr/local/bin/docker-compose restart
;;
*)
log_action_msg "Usage:
{start|stop|restart|logs}" || true
exit 1
esac
/etc/init.d/ssh
exit 0
[Bugfix] Avatar des utilisateurs/groupes
Dans docker-compose.yml, la ligne
- ./attachments:/loomio/public/system/attachments
sert à conserver les fichiers joints aux discussions hors du
container pour éviter de les perdre à chaque mise à jour. Nous
l’avons remplacé sur notre instance par
- ./uploads:/loomio/public/system/
pour conserver également les avatars uploadés qui se trouvent
dans
/loomio/public/system/users
et
/loomio/public/system/groups.
3 – Arroser
PostgreSQL
Il faut maintenant créer la base de données.
docker-compose run loomio rake db:setup
Loomio
La base de données est prête, vous pouvez démarrer Loomio.
docker-compose up -d
La commande se charge de lancer tous les containers
nécessaires. Pour pouvez vérifier leur statut en lançant la
commande docker-compose logs ou service loomio logs
Tests
Voici une liste de tâches à effectuer pour s’assurer que tout
fonctionne bien :
Créez un compte et un groupe puis déconnectez-vous.
Demandez une réinitialisation de mot de passe et
vérifiez que vous recevez bien le courriel.
Ouvrez une page de discussion dans 2 onglets et
saisissez un commentaire dans l’un. Le commentaire
devrait apparaître dynamiquement sur l’autre onglet.
Uploadez un fichier à une discussion et un avatar
personnalisé à votre compte ou à un groupe.
Vérifiez que vous pouvez répondre à une discussion par
courriel.
Créée une proposition avec une date de clôture proche
pour vérifier qu’elle se ferme automatiquement dans
l’heure.
4 – Pailler
Personnalisation
À ce stade, si tout s’est bien passé, lorsque vous consultez
le site votre-domaine.org, vous devriez être redirigé vers la
page votre-domaine.org/marketing. Il s’agit de la page de
présentation propre au site loomio.org, vous pourriez vouloir
en modifier le contenu.
Apparemment, les développeurs de Loomio ont enlevé le plugin
loomio_org du container depuis la rédaction de ce tutoriel. La
page d’accueil est maintenant la page de connexion, ça ne
change pas grand chose pour sur la méthode pour personnaliser
le logiciel mais si vous voulez quand même utiliser la page
« marketing », lisez ce commentaire.
Pour cela vous pouvez vous inspirer de ce que nous avons fait
pour Framavox.
Nous avons créé un dossier framavox/template dans lequel se
trouvent les fichiers à remplacer dans le container et nous
avons modifié le fichier docker-compose.yml en fonction.
volumes:
./framavox/template/angular.html.haml:/loomio/app/views/layout
s/angular.html.haml
./framavox/template/application.html.haml:/loomio/app/views/la
youts/application.html.haml
./framavox/template/marketing.html.haml:/loomio/plugins/loomio
_org_plugin/views/pages/marketing.html.haml
./framavox/template/_metadata.html.haml:/loomio/app/views/angu
lar/_metadata.html.haml
./framavox/template/_social_metadata.html.haml:/loomio/app/vie
ws/application/_social_metadata.html.haml
Même chose avec les fichiers de traduction qui étaient
incomplets.
./framavox/locales/client.fr.yml:/loomio/config/locales/client
.fr.yml
- ./framavox/locales/fr.yml:/loomio/config/locales/fr.yml
./framavox/locales/server.fr.yml:/loomio/config/locales/server
.fr.yml
L’essentiel de l’interface de Loomio se trouve dans
/loomio/app/views/ ou dans le plugin loomio.org (il s’agit
d’un dépôt à part dont le contenu est placé dans
/loomio/plugins/). Le reste se trouve dans les fichiers de
langue.
Avant
d’effectuer
des
modifications
au
fichier
docker-
compose.yml ou au fichier env, pensez à supprimer proprement
les containers docker-compose down et les redémarrer ensuite
docker-compose up -d
Quelques commandes utiles
docker exec -it loomiodeploy_loomio_1 /bin/bash pour
entrer dans le container loomio en cours d’utilisation
(pour voir précisément où se trouvent les fichiers à
modifier par exemple)
docker restart loomiodeploy_container_1 redémarre un
container (pour vérifier les changements dans un fichier
de template par exemple sans devoir tout redémarrer)
docker ps -a affiche la liste de tous les containers
présent sur la machine
docker stop loomiodeploy_container_1 arrête un container
docker rm loomiodeploy_container_1 le supprime
docker-compose pull pour mettre à jour tous les
containers (après un docker-compose down)
Installation de uMap
Attention La peinture est fraîche, cette page est amenée à
évoluer. Si vous avez besoin de plus de détails, la
documentation officielle (en anglais) se trouve sur le dépôt
de uMap.
uMap est le logiciel de personnalisation de cartes
géographiques que nous proposons sur Framacarte en partenariat
avec OpenStreetMap France.
Voici un tutoriel pour vous aider à l’installer sur votre
serveur.
N’hésitez pas à poser des questions dans les commentaires. Si
vous êtes parvenu à l’installer, donnez-nous le lien vers
votre instance et dites-nous dans quelle mesure ce tutoriel
vous aura été utile
Informations
Dans la suite de ce tutoriel, les instructions seront données
pour un serveur dédié sous Debian Jessie avec une base de
données PostgreSQL et un serveur web NginX.
Nous supposerons que vous avez déjà fait pointer votre nom de
domaine sur votre serveur auprès de votre registraire.
Prérequis
Python 3.4, PostgreSQL, PostGIS, Git
Pour faire fonctionner uMap, il est nécessaire d’installer
Python 3.4, PostgreSQL 9.4, PostGIS et quelques dépendances.
Sur Debian :
apt-get install postgresql postgresql-server-dev-9.4 postgis
python-pip git python-virtualenv virtualenvwrapper python3-dev
python3-setuptools libtiff5-dev libjpeg62-turbo-dev zlib1g-dev
libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev
python-tk python3.4-dev python-dev
apt-get build-dep python-imaging
Installation
1 – Préparer la terre
Tout d’abord, connectez-vous en tant que root sur votre
serveur et créez un compte utilisateur umap ainsi que son
dossier /home/umap dans lequel seront copiés les fichiers avec
les droits d’accès correspondants.
useradd -N umap -m
usermod -s /bin/bash umap
2 – Semer
Connectez-vous avec l’utilisateur umap : su umap
Téléchargez le dépôt git officiel dans
/home/umap/src
un
dossier
cd /home/umap
git clone https://github.com/umap-project/umap src
Créez un environnement virtuel Python :
mkvirtualenv umap --python=`which python3.4`
source .virtualenvs/umap/bin/activate
Installez les librairies requises :
cd src
pip install django-appconf
pip install -r requirements.txt
3 – Arroser
PostgreSQL
Il faut maintenant créer la base de données et configurer
uMap. Ajoutez tout d’abord un utilisateur umap et sa base de
données associée dans PostgreSQL :
sudo -u postgres createuser umap
sudo -u postgres createdb umap -O umap
Puis crée l’extension PostGis
sudo -u postgres psql umap
CREATE EXTENSION postgis;
(\q pour sortir de psql)
uMap
Maintenant que la base de données est prête, il faut
configurer uMap. Éditez le fichier umap/settings/local.py sur
le modèle du fichier local.py.sample :
cp umap/settings/local.py.sample umap/settings/local.py
nano umap/settings/local.py
Dans ce fichier, il est important de définir les paramètres :
SECRET_KEY : une longue chaîne de caractères aléatoires
DEBUG = False
ADMINS avec vos identifiants et adresse email
SOCIAL_AUTH_OPENSTREETMAP_KEY,
SOCIAL_AUTH_OPENSTREETMAP_SECRET
et
AUTHENTICATION_BACKENDS si vous voulez proposer à vos
utilisateurs d’avoir un compte pour gérer leurs cartes
(nous recommandons OpenStreetMap ici mais vous pouvez
aussi utiliser Twitter, Github ou Bitbucket)
UMAP_DEMO_SITE = False
SITE_URL = "https://votre-site.org"
SHORT_SITE_URL = "https://votre-site.org" (vous pouvez
utiliser un nom de domaine plus court s’il est configuré
comme un alias du nom de domaine principal)
MAPQUEST_KEY pour permettre la recherche de lieu
Clé OpenStreetMap et MapQuest
Pour obtenir les clés OpenStreetMap, il faut que vous ayez
enregistré un compte sur openstreetmap.org. Dans « Mes
options », « paramètres OAuth » ajoutez une « application
cliente ».
Pour obtenir la clé MapQuest, même chose : rendez-vous sur
developer.mapquest.com et remplissez le formulaire pour
obtenir votre clé d’API.
Le principe est quasiment le même pour Twitter, Github et
Bitbucket.
Il reste maintenant à remplir la base de données, importer en
cache les fichiers statiques, créer le compte administrateur
d’uMap.
python manage.py migrate
python manage.py collectstatic
python manage.py createsuperuser
4 – Pailler
À ce stade, si tout s’est bien passé, lorsque vous exécutez
cette commande :
python manage.py runserver 0.0.0.0:8019
uMap est fonctionnel. La page d’accueil sur l’URL
http://ip_de_votre_serveur:8019/ tourne mais il ne sera pas
encore possible de créer des cartes tant qu’on aura pas ajouté
des fonds de carte.
Fonds de carte
Pour cela, connectez-vous avez le compte admin précédemment
créé sur http://ip_de_votre_serveur:8019/admin et cliquez sur
« Tile layers → Ajouter ».
Voici ci-dessous la liste des fonds de carte présents sur
Framacarte :
Fonds de carte de Framacarte
Nom
URL
Attribution
Map tiles by
CartoDB, under
Positron
https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png
CC BY 3.0.
Data by
OpenStreetMap,
under ODbL.
Nom
URL
Attribution
Map tiles by
CartoDB, under
Dark Matter
https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png
CC BY 3.0.
Data by
OpenStreetMap,
under ODbL.
“OpenCycleMap”
OpenCycleMap
Outdoors
https://{s}.tile.thunderforest.com/cycle/{z}/{x}/{y}.png
https://{s}.tile.thunderforest.com/outdoors/{z}/{x}/{y}.png
and
“OpenStreetMap
contributors”
Tiles ©
Gravitystorm /
map data
OpenStreetMap
Processus silencieux – UWSGI
Pour lancer uMap en tant que service afin d’éviter devoir
garer un terminal ouvert en permanence, on utilise uswgi.
Installez uwsgi apt-get install uwsgi.
Dans le dossier /home/umap créer un
contenant :
fichier
[uwsgi]
uid = umap
gid = users
# Django-related settings
# the base directory (full path)
chdir
= /home/umap/src
# Django's wsgi file
module
= umap.wsgi
# the virtualenv (full path)
home
= /home/umap/.virtualenvs/umap
# process-related settings
# master
master
= true
# maximum number of worker processes
processes
= 8
# the socket (use the full path to be safe
socket
= /home/umap/umap.sock
# ... with appropriate permissions - may be needed
chmod-socket
= 666
# clear environment on exit
vacuum
= true
uswgi.ini
plugins
= python3
Ainsi qu’un fichier uwsgi_params (utilisé par Nginx) :
uwsgi_param
uwsgi_param
uwsgi_param
uwsgi_param
QUERY_STRING
REQUEST_METHOD
CONTENT_TYPE
CONTENT_LENGTH
$query_string;
$request_method;
$content_type;
$content_length;
uwsgi_param
uwsgi_param
uwsgi_param
uwsgi_param
uwsgi_param
uwsgi_param
REQUEST_URI
PATH_INFO
DOCUMENT_ROOT
SERVER_PROTOCOL
REQUEST_SCHEME
HTTPS
$request_uri;
$document_uri;
$document_root;
$server_protocol;
$scheme;
$https if_not_empty;
uwsgi_param
uwsgi_param
uwsgi_param
uwsgi_param
REMOTE_ADDR
REMOTE_PORT
SERVER_PORT
SERVER_NAME
$remote_addr;
$remote_port;
$server_port;
$server_name;
et créer un lien symbolique pour activer « l’application »
dans UWSGI
sudo
ln
-s
/home/umap/uwsgi.ini
enabled/umap.ini
service uwsgi restart
/etc/uwsgi/apps-
Pour lancer uMap, il suffira maintenant de taper service uwsgi
start umap
Nginx
Nous allons maintenant configurer uMap pour le rendre
accessible depuis un nom de domaine avec Nginx.
Installez nginx apt-get install nginx.
Dans le dossier /etc/sites-available, en tant que root, créez
un fichier votre-site.org.vhost s’il n’existe pas déjà
contenant :
# the upstream component nginx needs to connect to
upstream umap {
server unix:///home/umap/umap.sock;
}
proxy_cache_path
/tmp/nginx_ajax_proxy_cache
keys_zone=ajax_proxy:10m inactive=60m;
proxy_cache_key "$args";
# configuration of the server
server {
# the port your site will be served on
listen
80;
listen
[::]:80;
listen
443 ssl;
listen
[::]:443 ssl;
# the domain name it will serve for
server_name votre-site.org www.votre-site.org;
charset
utf-8;
levels=1:2
# https redirection
if ($scheme = http) {
return 301 https://votre-site.org$request_uri;
}
if ($host = www.votre-site.org) {
return 301 https://votre-site.org$request_uri;
}
# SSL conf
ssl_certificate
/etc/ssl/private/votresite.org.chained.pem;
ssl_certificate_key /etc/ssl/private/votre-site.org.key;
ssl_session_timeout 5m;
ssl_session_cache shared:SSL:5m;
ssl_dhparam /etc/ssl/private/dh2048.pem;
ssl_prefer_server_ciphers on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # not possible to do
exclusive
ssl_ciphers
'EDH+CAMELLIA:EDH+aRSA:EECDH+aRSA+AESGCM:EECDH+aRSA+SHA384:EEC
DH+aRSA+SHA256:EECDH:+CAMELLIA256:+AES256:+CAMELLIA128:+AES128
:+SSLv3:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!DSS:!RC4:!SEE
D:!ECDSA:CAMELLIA256-SHA:AES256-SHA:CAMELLIA128-SHA:AES128SHA';
# OCSP conf
ssl_stapling on;
ssl_stapling_verify on;
resolver_timeout 5s;
resolver 80.67.188.188
valid=300s;
[2001:913::8]
80.67.169.12
# STS conf
add_header Strict-Transport-Security max-age=15768000; #
six months
# max upload size
client_max_body_size 25M;
# adjust to taste
# Django media
location /uploads/ {
alias /home/umap/.virtualenvs/umap/var/uploads/;
expires 30d;
}
location /static/ {
alias /home/umap/.virtualenvs/umap/var/static/;
}
# X-Accel-Redirect
location /internal/ {
gzip off;
add_header Content-Encoding gzip;
internal;
alias /home/umap/.virtualenvs/umap/var/uploads/;
}
location /ajax-proxy/ {
valid_referers server_names;
if ($invalid_referer) {
return 404;
}
if ($args !~ ^url=(.*)$) {
return 404;
}
if ($args ~ ^url=(.*)$) {
set $target $1;
}
add_header X-Proxy-Cache $upstream_cache_status;
proxy_pass $target;
proxy_cache ajax_proxy;
proxy_cache_valid 3m;
}
# Finally, send all non-media requests to the Django
server.
location / {
uwsgi_pass umap;
include
/home/umap/uwsgi_params;
}
}
Copiez votre clé et votre certificat SSL (votre-site.org.key
et votre-site.org.chained.pem) pour l’utilisation du https
dans le dossier /etc/ssl/private/.
Créez un lien symbolique pour activer le site et enfin,
relancez Nginx :
sudo
ln
-s
/etc/nginx/sites-available/votre-site.org
/etc/nginx/sites-enabled/votre-site.org
service nginx restart
Installation de Framadate
Framadate est le logiciel de création de sondages que nous
développons et proposons comme service en ligne. Il est
initialement basé sur le logiciel Studs développé par
l’université de Strasbourg et que nous avons largement
remanié.
Voici un tutoriel pour vous aider à l’installer sur votre
serveur.
N’hésitez pas à poser des questions dans les commentaires. Si
vous êtes parvenu à l’installer, donnez-nous le lien vers
votre instance et dites-nous dans quelle mesure ce tutoriel
vous aura été utile
Informations
Dans la suite de ce tutoriel, les instructions seront données
pour un serveur dédié sous Debian Wheezy avec une base de
données MySQL, un serveur web Apache (ou NginX), PHP 5.4
(minimum), Postfix (ou Exim ; pour l’envoi des courriels) et
Git d’installés.
Nous supposerons que vous avez déjà fait pointer votre nom de
domaine sur votre serveur auprès de votre registraire.
Installation
1 – Préparer la terre
Tout d’abord, connectez-vous en tant que root sur votre
serveur et créez un compte utilisateur framadate ainsi que le
dossier /var/www/framadate dans lequel seront copiés les
fichiers avec les droits d’accès correspondants.
useradd framadate
groupadd framadate
mkdir /var/www/framadate
chown framadate:framadate -R /var/www/framadate
2 – Semer
Connectez-vous avec l’utilisateur framadate : su framadate -s
/bin/bash
Puis, téléchargez les fichiers de notre dépôt avec Git depuis
le dossier /var/www/framadate et basculez sur la dernière
version stable (dans l’exemple 0.9.3).
cd /var/www/framadate
git clone https://git.framasoft.org/framasoft/framadate.git .
git checkout 0.9.3
Installez également l’extension php intl :
sudo apt-get install php5-intl
Framadate s’appuie sur le logiciel Composer pour importer les
librairies dont il dépend. Pour l’installer, lancez la
commande
php -r "readfile('https://getcomposer.org/installer');" | php
et importez les librairies nécessaires
./composer.phar install
./composer.phar update
3 – Arroser
MySQL
Il faut maintenant créer la base de données et configurer
Framadate.
Installez tout d’abord le paquet mysql-server (notez le mot de
passe root) et démarrez MySQL : service mysql start
Créez un utilisateur et une base de données framadate. Sur
votre serveur dédié vous pouvez utiliser PhpMyAdmin qui est
souvent pré-installé, sinon voici comment faire avec Adminer.
Téléchargez Adminer en ligne de commande (toujours depuis le
dossier /var/www/framadate).
wget -O adminer.php http://www.adminer.org/latest-mysql.php
Connectez-vous avec le compte root MySQL sur votre-nom-dedomaine.org/adminer.php et cliquez sur « Créer une base de
données ».
Remplissez le nom de la base de données et le type d’encodage,
ici framadate – latin_swedish_ci.
Une fois créée, cliquez sur « Privilèges » et « Créer un
utilisateur ».
Remplissez
les
champs
Serveur
localhost,
Utilisateur framadate, Mot de passe, Privilèges `framadate`.*
et cochez la case All privileges.
Par sécurité, vous pouvez supprimer le fichier adminer.php qui
n’est plus nécessaire.
Framadate
Maintenant que la base de données est prête, il faut
configurer Framadate pour pouvoir s’en servir.
Rendez-vous
ensuite
sur
la
page
votre-nom-dedomaine.org/admin/install.php. Et remplissez le formulaire
avec
comme
chaîne
de
connexion
mysql:host=localhost;dbname=framadate;port=3306, l’utilisateur
framadate et le mot de passe tel que vous l’avez défini à
l’étape précédente.
Si la page ne s’affiche pas, vérifiez qu’un dossier
`/var/www/framadate/tpl_c` a bien été créé avec des droits en
écriture suffisant.
À l’installation, les tables de la base de données et le
fichier app/inc/config.php sont créés. Le fichier
app/inc/config.php contient d’autres paramètres
configuration facultatifs que vous pouvez modifier.
de
Vous êtes ensuite redirigé vers la page de « migration » qui
sert à contrôler que les tables et données sont dans le bon
format. Pour les mises à jour ultérieures, il faudra passer
par cette page après remplacement des fichiers.
Espace admin
Framadate dispose d’un espace d’administration de l’ensemble
des sondages dans le dossier /admin
Pour en restreindre l’accès, il faut ajouter au fichier de
configuration Apache de votre site web (fichier
/etc/apache2/sites-enabled/votre-domaine.vhost) ce bloc :
<Directory "/var/www/framadate/admin/">
AuthType Basic
AuthName "Administration"
AuthUserFile "/var/www/framadate/admin/.htpasswd"
Require valid-user
Order allow,deny
Allow from all
</Directory>
et créer le fichier .htpasswd contenant l’utilisateur et le
mot de passe autorisé.
htpasswd -bc /var/www/framadate/admin/.htpasswd utilisateur
mot-de-passe
(l’utilitaire htpasswd se trouve dans le paquet apache2-utils)
Pour protéger les fichiers .htaccess et .htpasswd, pensez à
ajouter également ceci :
<FilesMatch "^\.ht.*">
deny from all
satisfy all
ErrorDocument 403 "Accès refusé."
</FilesMatch>
Réécriture d’URL
Pour activer la réécriture d’URL afin d’avoir des liens sous
la forme http://votre-domaine.org/a1b2c3d4e5f6g7h8 au lieu de
http://votre-domaine.org/studs.php?sondage=a1b2c3d4e5f6g7h8.
Il faut ajouter une ligne AllowOverride All dans le fichier
.vhost pour autoriser l’utilisation des .htaccess sur votre
domaine et renommer le fichier /var/www/framadate/htaccess.txt
en /var/www/framadate/.htaccess
Et voilà ! Normalement, ça pousse tout seul
Informations
En complément, voici un tutoriel pour installer Framadate sur
Ubuntu 14.04 de Patrick Harmel, sous licence GFDL.
Installation de LUFI
Attention La peinture est fraîche, cette page est amenée à
évoluer rapidement. Lufi s’installe de la même manière que
Lutim. Si vous avez besoin de plus de détail la documentation
officielle (en anglais) se trouve sur le dépôt de Lufi.
Lufi est le logiciel d’hébergement de fichier que nous
proposons sur Framadrop.
Voici un tutoriel pour vous aider à l’installer sur votre
serveur.
N’hésitez pas à poser des questions dans les commentaires. Si
vous êtes parvenu à l’installer, donnez-nous le lien vers
votre instance et dites-nous dans quelle mesure ce tutoriel
vous aura été utile
Informations
Dans la suite de ce tutoriel, nous supposerons que vous avez
déjà fait pointer votre nom de domaine sur votre serveur
auprès de votre registraire et que vous disposez d’un serveur
dédié sous Debian.
Prérequis
Lufi est codé en Perl, pour le faire fonctionner il est
nécessaire d’installer Carton, un gestionnaire de modules
Perl.
cpan Carton
Installation
1 – Préparer la terre
Tout d’abord, connectez-vous en tant que root sur votre
serveur et créez un compte utilisateur lufi ainsi que le
dossier /var/www/lufi dans lequel seront copiés les fichiers
avec les droits d’accès correspondants.
useradd lufi
groupadd lufi
mkdir /var/www/lufi
chown -R lufi:lufi /var/www/lufi
2 – Semer
Téléchargez les fichiers de la dernière version sur le dépôt
officiel (« Download zip » en bas à droite ou bien en ligne de
commande avec git), copiez son contenu dans le dossier
/var/www/lufi et attribuez les droits des fichiers à
l’utilisateur lufi
cd /var/www/
git clone https://git.framasoft.org/luc/lufi.git
chown lufi:lufi -R /var/www/lufi
Connectez-vous avec l’utilisateur lufi : su lufi -s /bin/bash
et lancez la commande d’installation des dépendances depuis le
dossier /var/www/lufi
cd /var/www/lufi
su lufi -s /bin/bash
carton install
Maintenant
que
tout
est
prêt,
modifiez
le
fichier
de
configuration de Lufi lufi.conf avec votre éditeur de texte
préféré sur le modèle du fichier lufi.conf.template.
Par défaut le logiciel est configuré pour écouter sur le port
8080 de l’adresse 127.0.0.1 (localhost).
cp lufi.conf.template lufi.conf
vi lufi.conf</pre>
L’ensemble des paramètres sont facultatifs à l’exception du
paramètre contact (pensez bien à le configurer et à le
décommenter). Si vous utilisez Lufi derrière un serveur web
comme Nginx (comme dans ce tutoriel),
décommenter le paramètre proxy => 1,.
pensez
bien
à
Lufi en tant que service
À présent, le serveur tournera lorsque qu’on lancera en tant
que root cette commande :
carton exec hypnotoad script/lufi
Pour éviter de devoir relancer le serveur à la main à chaque
redémarrage du serveur, on va donc lancer Lufi sous forme de
service.
Pour InitV
Il faut pour ça copier le script utilities/lufi.init dans le
fichier /etc/init.d/lufi, le rendre exécutable puis copier le
fichier utilities/lufi.default dans /etc/default/lufi.
cp utilities/lufi.init /etc/init.d/lufi
cp utilities/lufi.default /etc/default/lufi
Il faut maintenant modifier /etc/default/lufi pour y mettre le
chemin d’installation de notre Lufi (/var/www/lufi si vous
n’avez pas changé le chemin préconisé par ce tutoriel)
vi /etc/default/lufi
chmod +x /etc/init.d/lufi
chown root:root /etc/init.d/lufi /etc/default/lufi
Pour Systemd
cp utilities/lufi.service /etc/systemd/system
Modifiez ce fichier pour qu’il corresponde à votre
installation (utilisateur, chemin d’installation…)
vi /etc/systemd/system/lufi.service
Faites en sorte que Systemd le prenne en compte
systemctl daemon-reload
Et qu’il le lance à chaque démarrage
systemctl enable lufi.service
4 – Pailler
À ce stade, si tout s’est bien passé, lorsque vous exécutez la
commande service lufi start, Lufi est pleinement fonctionnel.
Vous n’avez qu’à vous rendre sur l’URL http://127.0.0.1:8080
pour pouvoir l’utiliser.
Nous allons maintenant configurer Lufi pour le rendre
accessible depuis un nom de domaine avec Nginx (vous pouvez
également utiliser Apache ou Varnish puisque seule la
fonctionnalité de proxy inverse nous intéresse).
Nginx
Installez le paquet :
apt-get install nginx
Créez le fichier de configuration de votre domaine
/etc/nginx/sites-available/votre-nom-de-domaine pour y mettre
ceci (en remplaçant « votre-nom-de-domaine ») et le port 8080
si vous l’avez changé dans la configuration de Lufi :
server {
listen 80;
server_name votre-nom-de-domaine;
access_log /var/log/nginx/lufi.success.log;
error_log /var/log/nginx/lufi.error.log;
location / {
# Add cache for static files
if ($request_uri ~* ^/(img|css|font|js)/) {
add_header Expires "Thu, 31 Dec 2037 23:55:55
GMT";
add_header Cache-Control "public, maxage=315360000";
}
# HTTPS only header, improves security
#add_header Strict-Transport-Security "maxage=15768000";
# Adapt this to your configuration
proxy_pass http://127.0.0.1:8080;
# Really important! Lufi uses WebSocket, it won't work
without this
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header
X-Forwarded-For
$proxy_add_x_forwarded_for;
# If you want to log the remote port of the file
senders, you'll need that
proxy_set_header X-Remote-Port $remote_port;
proxy_set_header X-Forwarded-Proto $scheme;
# We expect the downstream servers to redirect to the
right hostname, so don't do any rewrites here.
proxy_redirect
off;
}
}
Activez votre fichier :
ln
-s
/etc/nginx/sites-available/votre-nom-de-domaine
/etc/nginx/sites-enabled/votre-nom-de-domaine
Enfin, relancez nginx :
service restart nginx
5 – Tailler et désherber
Pour personnaliser votre instance de Lufi, il faut lancer la
commande carton exec script/lufi theme votre-theme, ce qui
créera un nouveau dossier themes/votre-theme.
Il contiendra un fichier Makefile, un fichier lib/Lufi/I18N.pm
ainsi que des dossiers vides pour vous montrer le
« squelette » d’un thème. Ensuite il ne vous reste plus qu’à
copier les fichiers du thème default dans votre dossier de
thème et à les adapter à votre gré. Vous pouvez ainsi modifier
les fichiers css, images, javascript (dossier public), les
modèles de pages (dossier templates) et même la traduction en
conservant un thème propre sur lequel basculer en cas de
problème.
Le cas de la modification des traductions est un peu
particulier :
si vous souhaitez ajouter des chaînes de caractères
traduites dans votre thème, ajoutez-les dans les
fichiers du dossier templates en prenant exemple sur le
thème par défaut (<%= l('Ceci est une chaîne traduite')
%>) puis exécutez make locales depuis votre dossier de
thème (themes/votre-theme, pas depuis le dossier
d’installation de Lufi). Il vous restera alors à ajouter
la traduction dans les fichiers présents dans
themes/votre-theme/lib/Lufi/I18N/.
si vous souhaitez modifier une traduction, repérez la
chaîne
dans
les
fichiers
de
themes/default/lib/Lufi/I18N/, puis recopiez les lignes
commençant par msgid et msgstr qui s’y rapportent (ne
copiez surtout pas les commentaires qui s’y rapportent).
Enfin, modifiez la traduction (le contenu de msgstr)
dans vos fichiers.
Modifiez ensuite le fichier lufi.conf pour préciser quel thème
vous utilisez. Pour pouvoir personnaliser et observer vos
modifications en direct, il vous faudra stopper temporairement
le service service lufi stop et le démarrer avec la commande :
carton exec morbo script/lufi --listen=http://127.0.0.1:8080
Installation de Kanboard
Kanboard est le logiciel de gestion de projets que nous
proposons sur framaboard.org. Voici un tutoriel pour
l’installer sur votre serveur.
N’hésitez pas à poser vos questions dans les commentaires. Si
vous êtes parvenu à l’installer, donnez-nous le lien vers
votre instance et dites-nous dans quelle mesure ce tutoriel
vous aura été utile :).
Nous considérerons dans la suite de ce tutoriel que vous
disposez d’un serveur sous Debian 8 (Jessie) avec les
logiciels Apache et PHP (5.3.3 minimum) installés. Si vous
vous trouvez dans une autre configuration, n’hésitez pas à
jeter un coup d’œil à la documentation officielle qui est très
bien faite (mais en anglais). Nous supposerons que vous avez
déjà fait pointer votre nom de domaine sur votre serveur
auprès de votre registraire.
Pré-requis
Vous devez d’abord installer les paquets requis par Kanboard
pour fonctionner correctement (ou vous assurer qu’ils le
sont) :
$ apt-get install -y php5-sqlite php5-gd unzip
Installation
1 – Semer
Téléchargez
la
dernière
version
de
Kanboard
sur
kanboard.net/downloads (le lien « Stable version »).
Décompressez l’archive et uploadez les fichiers sur votre
serveur web.
Vous
n’avez
plus
qu’à
vous
rendre
sur
http://votre-site.org/kanboard/. Les identifiants par défaut
sont admin et admin.
Pour fonctionner, vous devez vous assurer que le répertoire
kanboard/data est accessible en écriture par le serveur web.
2 – Tailler et désherber
Par défaut, les identifiants sont admin / admin : il n’est pas
recommandé de les laisser tels quels ! Une fois connecté,
rendez-vous dans « Gestion des utilisateurs > admin > Changer
le mot de passe ». Vous pouvez aussi changer le nom
d’utilisateur en allant sur « Modifier le profil ».
Vous pouvez désormais commencer à utiliser Kanboard !
Installation de Owncloud
Framadrive est le service de stockage de fichiers proposé par
Framasoft basé sur le logiciel Owncloud.
Comme nous sommes (un peu) en retard, nous n’avons pas encore
fini la documentation spécifique à la mise en place de
Framadrive. Cependant, sachez qu’il s’agit à très peu de
choses près d’une installation standard d’Owncloud. Vous
trouverez donc ci-dessous :
Le manuel officiel d’installation d’Owncloud
anglais)
Des tutoriels d’installation en français
Ubuntu-fr
IT-Connect
(en