eLabFTW@INRAE : Documentation technique -

Mise en place d’un serveur hébergeant l’application eLabFTW

Auteur:

Éric Quinton

date: 17 janvier 2025

update: 20 janvier 2025

Relecture

François Ehrenmann

date: 25 février 2025

update: 04 avril 2025

Ce document a été créé au moment de la mise en place d’un serveur hébergeant l’application eLabFTW et destiné à servir de démonstrateur.

La configuration décrite ici peut être reproduite pour créer, administrer et maintenir sa propre instance. (instance On premise selon la terminologie du projet eLabFTW@INRAE).

Présentation générale

Le serveur repose et fonctionne sur une machine virtuelle créée par la DSI, et dont la configuration est décrite dans ce document : Configuration de base d’une machine et d’un serveur virtuel. Le serveur tourne sous la distribution Ubuntu en version 24.04.1 LTS. Il est fortement conseillé de mettre en œuvre l’ensemble de la configuration décrite dans ce document !

L’application eLabFTW est déployée dans un container Docker. La base de données est montée dans un service MySQL, cependant le choix est fait dans cette procédure d’installer MySQL directement sur le serveur (pas de “containerisation” sous Docker). Les fichiers associés sont stockés dans l’infrastructure de la DSI, soit avec un montage NFS, soit avec un montage S3 géré directement par l’application.

Gestion des incidents du serveur et demandes

En cas de souci de fonctionnement ou pour toute demande, par exemple pour réaliser un snapshot de votre serveur, vous pouvez ouvrir un ticket ici : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=906528a10a0a0bf000a85bc20dfb6541&sys_parm_service=49dcb31237ec4200275c261953990e6e

Configurer l’espace disque

Le partitionnement mis en place dans la procédure Configuration de base d’une machine et d’un serveur virtuel est le suivant, après redimensionnement de /var et de /opt :

df -h
Filesystem                Size  Used Avail Use% Mounted on
tmpfs                     392M  1,3M  390M   1% /run
/dev/mapper/vg1-root      5,4G  3,8G  1,4G  74% /
tmpfs                     2,0G     0  2,0G   0% /dev/shm
tmpfs                     5,0M     0  5,0M   0% /run/lock
/dev/sda1                 462M  180M  254M  42% /boot
/dev/mapper/vg1-opt       5,9G   56K  5,6G   1% /opt
/dev/mapper/vg1-home      920M  120K  857M   1% /home
/dev/mapper/vg1-tmp       920M   68K  857M   1% /tmp
/dev/mapper/vg1-var        24G  1,9G   21G   9% /var
/dev/mapper/vg1-varlog    1,8G  226M  1,5G  14% /var/log
/dev/mapper/vg1-varspool  2,7G  600K  2,6G   1% /var/spool
tmpfs                     392M  4,0K  392M   1% /run/user/1002

Installer ElabFTW

Installer Docker

L’installation est réalisée en suivant les instructions décrites ici : https://docs.docker.com/engine/install/ubuntu/

Note : vous aurez peut-être besoin d’installer l’outil curl (apt install curl)

Note : si machine virtuelle DEBIAN, remplacer ubuntu par debian

# Add Docker's official GPG key:
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Vérifiez l’installation correcte de docker dans un terminal avec la commande :

docker run hello-world

Installer eLabFTW

La documentation d’installation est disponible sur le site officiel : https://doc.elabftw.net/install.html

Récupérer le fichier docker-compose.yml :

Dans un terminal, lancer les commandes suivantes :

mkdir /opt/elabftw
cd /opt/elabftw
curl -so docker-compose.yml "https://get.elabftw.net/?config"

Le fichier doit être adapté pour que le serveur mysql et les fichiers stockés dans l’application soient correctement paramétrés :

cd /opt/elabftw
mv docker-compose.yml docker-compose-origin.yml
cat docker-compose-origin.yml |grep -v "^ *\(--\|#\)"|grep .>docker-compose.yml

Vous devrez supprimer tout ce qui concerne le container mysql (à partir de mysql:) et adapter la configuration de docker-compose.yml ainsi :

name: elabftw
networks:
  elabftw-net:
services:
  web:
    image: elabftw/elabimg:stable
    restart: always
    container_name: elabftw
    security_opt:
      - no-new-privileges:true
    cap_drop:
        - ALL
    cap_add:
        - CHOWN
        - SETGID
        - SETUID
        - FOWNER
        - DAC_OVERRIDE
    environment:
        - DB_HOST=172.18.0.1
        - DB_PORT=3306
        - DB_NAME=elabftw
        - DB_USER=elabftw
        - DB_PASSWORD=MOT DE PASSE FOURNI DANS LE FICHIER ORIGINEL
        - PHP_TIMEZONE=Europe/Paris
        - TZ=Europe/Paris
        - SECRET_KEY=CLE FOURNIE DANS LE FICHIER ORIGINEL
        - SITE_URL=https://SERVERNAME.inrae.fr (mettez ici le lien de votre site, par exemple elab-nom-unite-ou-centre.inrae.fr)
        - SERVER_NAME=SERVERNAME.inrae.fr (mettez ici le lien de votre instance, par exemple elab-nom-unite-ou-centre.inrae.fr)
        - DISABLE_HTTPS=true
        - ENABLE_LETSENCRYPT=false
    ports:
        - '3148:443'
    volumes:
        - /opt/elabdoc:/elabftw/uploads
        - /opt/elabftw:/etc/nginx/certs
    networks:
      - elabftw-net

Les variables DB_PASSWORD et SECRET_KEY sont issues du fichier docker-compose.yml récupéré depuis le site de eLabFTW, et doivent être conservées à leur valeur d’origine.

La variable DB_HOST correspond à l’adresse de votre serveur connue par le réseau docker. Vous pouvez vérifier sa valeur dans un terminal avec la commande suivante :

ip a
(...)
6: br-379e1dd04019: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:22:9b:87:ed brd ff:ff:ff:ff:ff:ff
    inet 172.18.0.1/16 brd 172.18.255.255 scope global br-379e1dd04019
(...)

Lancer la création du container

Dans un terminal, lancez les commandes suivantes :

cd /opt/elabftw
docker compose up -d
docker container ls

CONTAINER ID   IMAGE                    COMMAND   CREATED          STATUS                             PORTS                                       NAMES
b63241ea8c56   elabftw/elabimg:stable   "/init"   39 seconds ago   Up 38 seconds (health: starting)   0.0.0.0:3148->443/tcp, [::]:3148->443/tcp   elabftw

Créer la base de données

Installez le serveur mysql :

apt-get install mysql-server

Note : si machine virtuelle DEBIAN, suivre la documentation : https://dev.mysql.com/doc/refman/8.4/en/linux-installation-apt-repo.html

Lancez la commande mysql pour vous connecter au serveur mysql, puis saisissez les commandes suivantes (exemple avec compte USERNAME) :

# Creation of an administrator account
create user 'USERNAME'@'%' identified by 'motdepasse';
grant all privileges on *.* to 'USERNAME'@'%' with grant option;
create database elabftw;
create user 'elabftw'@'%' identified by 'motdepasse_issu_de_docker-compose.yml';
grant all on elabftw.* to 'elabftw'@'%';

Les deux premières commandes ne sont pas forcément utiles : elles ne servent que si vous souhaitez administrer la base de données depuis un autre ordinateur, sous réserve que le port mysql soit ouvert par la DSI au niveau du vpn.

Quittez mysql en saisissant exit ou \q.

Éditez le fichier /etc/mysql/mysql.conf.d/mysqld.cnf, et modifiez la ligne en indiquant :

bind-address            = 0.0.0.0

Pour autoriser les connexions depuis les différentes adresses IP, dont celles du container docker, qui contient l’application, relancez le serveur mysql :

systemctl restart mysql

Lancez la commande suivante pour déclencher la création de la base de données à partir du container docker :

docker exec -it elabftw bin/init db:install

Activer le stockage externe des documents

Les documents associés aux expériences décrites dans eLabFTW sont stockés dans une arborescence gérée par l’application. Leur volumétrie peut augmenter rapidement, et il est préférable de les stocker en dehors du serveur, dans un montage dédié issu de l’infrastructure de la DSI.

Deux technologies sont utilisables : soit un montage NFS, soit un accès direct vers un espace cloud s3. Le montage NFS est plus rapide en terme de vitesse d’accès aux fichiers, l’espace S3 est moins coûteux et est plus facile à gérer manuellement (interface web pour le consulter), et se paramètre depuis l’application.

Nous précisons ci-dessous la mise en place pour ces 2 types d’accès aux documents.

Créer un espace NFS

La demande est à réaliser ici : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=c51837bd0f377500db98936792050e17

Le montage va être réalisé dans le dossier /opt/elabdoc.

mkdir /opt/elabdoc

Éditez ensuite le fichier /etc/fstab, et rajoutez la ligne (exemple avec espace NFS nab_eabx_elabftw) :

10.131.xx.xx:/nab_eabx_elabftw/sandbox /opt/elabdoc nfs vers=3 0 0

Vous devrez peut-être monter d’abord le partage sans “sandbox”, puis créer le dossier sandbox (mkdir /opt/elabdoc/sandbox), et enfin refaire le montage avec le sous-dossier sandbox. Cette approche évite de visualiser d’autres espaces qui seraient dans le partage nfs.

Créer un espace S3

Faites une demande de création par un ticket Ariane : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=f851753ddb8643c0d614db45ce96196e. Une fois votre espace créé, connectez-vous à l’interface d’administration (https://cloud.inrae.fr) puis, une fois positionné dans votre espace S3 :

créez un conteneur pour stocker les fichiers
cherchez “Accès API”, puis Voir les paramètres du compte. Vous devez récupérer ces informations :
- URL S3
- clé d’accès EC2
- clé secrète EC2
- notez également le endpoint
- ainsi que la région, en principe inra-tls ou inra-geo-secure-tls

Modifiez le fichier opt/elabftw/docker-compose.yml, et rajoutez les deux variables suivantes dans la section environment :

ELAB_AWS_ACCESS_KEY : la clé d’accès
ELAB_AWS_SECRET_KEY : la clé secrète associée

Supprimez le container, puis recréez-le pour activer ces deux variables en lançant les commandes suivantes :

cd /opt/elabftw
docker container stop elabftw
docker container rm elabftw
docker compose up -d --build

L’activation du stockage dans l’espace S3 sera réalisée après l’étape "Mettre en place l’accès web au container" ci-dessous, c’est-à-dire une fois votre application web opérationnelle (cf. infra)

Connectez-vous alors en mode SYSADMIN. Pour cela, rendez-vous à l’URL suivante :

https://SERVERNAME.inrae.fr/register.php

puis positionnez-vous dans l’onglet Téléversements, en indiquant les informations suivantes :

Où les fichiers téléversés par les utilisateurs sont stockés : S3 bucket
S3 bucket name : nom du container créé dans votre espace (https://cloud.inrae.fr)
s3 région : inra-geo-secure-tls, par exemple
s3 endpoint : https://s3-tls.stockage.inra.fr ou https://s3r-tls.stockage.inra.fr (par exemple)

Faites ensuite un test de dépôt de fichier dans une expérience, puis vérifiez, dans l’interface https://cloud.inrae.fr, que le fichier a bien été créé dans votre container.

Mettre en place l’accès web au container

L’application web, intégrée dans le container, va être rendue accessible en activant une redirection par un proxy Apache.

Demander un certificat

La demande de certificat (csr) va être générée dans le dossier /etc/ssl/web/SERVERNAME.inrae.fr :

mkdir -p /etc/ssl/web/SERVERNAME.inrae.fr
cd /etc/ssl/web/SERVERNAME.inrae.fr
openssl req -new -newkey rsa:2048 -nodes -keyout privkey.pem -out elab-sandbox.csr
Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:.
Locality Name (eg, city) []:.
Organization Name (eg, company) [Internet Widgits Pty Ltd]:INRAE
Organizational Unit Name (eg, section) []:.
Common Name (e.g. server FQDN or YOUR name) []:SERVERNAME.inrae.fr
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Vous pouvez vérifier le contenu de la demande de certificat avec cette commande :

openssl req -noout -text -in elab-sandbox.csr

Recopiez le contenu du fichier csr, puis réalisez la demande de certificat par l’intermédiaire d’un ticket Ariane : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=f4fedf7a37d002006da398a543990e8a

Recopiez ensuite le certificat reçu via votre demande ariane dans le dossier /etc/ssl/web/SERVERNAME.inrae.fr, et assurez-vous qu’il s’appelle bien fullchain.pem.

Installer et configurer Apache

Une fois le certificat reçu, lancez les commandes suivantes pour installer le serveur web apache2 :

apt-get install apache2
a2enmod rewrite headers proxy ssl proxy_http

Puis créez le fichier /etc/apache2/sites-available/elab.conf :

<VirtualHost *:80>
  ServerName SERVERNAME.inrae.fr
  ServerPath /SERVERNAME.inrae.fr
  RewriteEngine On
  RewriteRule ^ https://SERVERNAME.inrae.fr%{REQUEST_URI} [R]
</VirtualHost>
<VirtualHost *:443>
 ServerName SERVERNAME.inrae.fr
    ServerPath /SERVERNAME.inrae.fr
    RequestHeader set X-Forwarded-Proto "http"
    ProxyPreserveHost On
    ProxyPass "/" "http://localhost:3148/"
    ProxyPassReverse "/" "http://localhost:3148"
    SSLEngine on
    SSLCertificateFile /etc/ssl/web/SERVERNAME.inrae.fr/fullchain.pem
    SSLCertificateKeyFile /etc/ssl/web/SERVERNAME.inrae.fr/privkey.pem
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384
    SSLProtocol all -SSLv3
    SSLHonorCipherOrder on
</VirtualHost>

Et enfin activez le site elab et redémarrez le serveur web :

a2ensite elab
systemctl restart apache2

Sauvegarder les données

Les données à sauvegarder sont :

le dossier /opt/elabftw/docker-compose.yml, qui contient la configuration du container docker et les clés d’identification utilisées par le protocole SASL (cf. infra)
la base de données
le contenu du dossier /opt/elabdoc, qui contient les fichiers associés aux expériences (uniquement si vous avez réalisé un montage NFS)

S’il est toujours possible de s’appuyer sur les fonctionnalités génériques de sauvegarde de la DSI (machine virtuelle, espace de stockage), il est toutefois conseillé de réaliser des sauvegardes manuelles indépendantes.

Créer espace de stockage S3

Créez un espace de stockage répliqué S3 par l’intermédiaire d’une demande Ariane : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=f851753ddb8643c0d614db45ce96196e Cet espace est à créer à Toulouse, avec réplication dans le datacenter d’île de France, pour limiter les risques de pertes d’informations.

Pour accéder à l’espace s3, vous devez installer le paquet suivant s3fs :

apt-get install s3fs

Dans l’interface https://cloud.inrae.fr, une fois positionné dans votre espace S3 :

créez un conteneur pour stocker les fichiers de sauvegarde, ici elab-sandbox
cherchez “Accès API”, puis Voir les paramètres du compte. Vous devez récupérer ces informations :
- URL S3
- clé d’accès EC2
- clé secrète EC2

Créez sur votre serveur un fichier contenant la clé d’accès :

echo cle_acces:cle_privee > /etc/s3access
chmod 600 /etc/s3access

Ajoutez une ligne dans le fichier /etc/fstab :

cp /etc/fstab /etc/fstab_ori
mkdir /mnt/elabftw_backup
echo elab-sandbox /mnt/elabftw_backup fuse.s3fs _netdev,allow_other,use_path_request_style,url=https://s3r-tls.stockage.inra.fr,passwd_file=/etc/s3access 0 0 >> /etc/fstab
systemctl daemon-reload
mount /mnt/elabftw_backup

elab-sandbox correspond au nom du container créé, et l’url est celle que vous avez récupéré depuis les paramètres de l’espace s3.

Vérifiez que le montage se soit bien déroulé :

mount -l|grep elabftw
s3fs on /mnt/elabftw_backup type fuse.s3fs (rw,relatime,user_id=0,group_id=0,allow_other)

Si le montage n’existe pas, vérifiez les messages d’erreur :

tail /var/log/syslog

Une fois le montage réalisé, ajoutez le fichier isalive.txt, qui sera utilisé pour vérifier l’existence du montage au moment de la sauvegarde :

touch /mnt/elabftw_backup/isalive.txt

Vous devriez retrouver ce fichier dans l’interface https://cloud.inrae.fr, dans les fichiers de votre container (ou bucket).

Mettre en place le script de sauvegarde

Créez un dossier sur votre serveur pour stocker le script de sauvegarde et les logs :

mkdir /opt/backup

Créez le fichier /opt/backup/backup.sh, avec le contenu suivant :

Note : Si le stockage des fichiers uploadés sont en S3, supprimer les variables du type UPLOADFOLDER dans le fichier ci-dessous ainsi que les lignes avec $RSYNC $UPLOADFOLDER

#!/bin/bash
  DUMPPATH=/mnt/elabftw_backup
  MYSQLFILE=$DUMPPATH/elabftw-`date +%Y%m%d%H%M`.sql.gz
  LOG=/opt/backup/elabftw-backup.log
  DOCKERFOLDER=/opt/elabftw
  UPLOADFOLDER=/opt/elabdoc
  DISTANTFOLDER=$DUMPPATH/elabdoc/
  FILENAME=$DUMPPATH/"elabftw-backup-`date +%Y%m%d%H%M`.zip"
  ALIVE="isalive.txt"
  RSYNC="/usr/bin/rsync -rt"
  BACKUPDISTANT=/mnt/elabftw_backup
  MAIL="/usr/bin/mail"
  SUBJECT="Sauvegarde de SERVERNAME.inrae.fr"
  DEST="gedeop-admin-elab@inrae.fr"
  echo *date* >$LOG
  echo "sauvegarde de mysql">>$LOG
  if [ -e $DUMPPATH/$ALIVE ] 
  then
      /usr/bin/mysqldump --all-databases |gzip  > $MYSQLFILE
      $RSYNC $UPLOADFOLDER/ $DISTANTFOLDER/
      $RSYNC $DOCKERFOLDER $DUMPATH/
      echo -n "fin de sauvegarde à " >> $LOG
      date >> $LOG
      echo "purge des anciens fichiers" >> $LOG
      NOW=`date +"%F %T"`
      # time difference [days]
      TDIFF=7
      if find $DUMPPATH/*gz -mtime +$TDIFF -type f -delete &>> $LOG; then
              echo "Zip files with datestamp @$NOW MINUS $TDIFF days removed" >> $LOG
      else
              echo "Files with $TDIFF days old timestamp not present : no data removed" >> $LOG
      fi
      echo "Liste des fichiers de sauvegarde mysql" >>$LOG
      ls -lh $DUMPPATH/|grep gz >>$LOG
  else
  	echo "$BACKUPDISTANT is not mounted! Backup aborted" >> $LOG
  	$MAIL -s "$SUBJECT" $DEST < $LOG
  fi

Puis programmez la sauvegarde :

chmod +x /opt/backup/backup.sh
(crontab -l ;echo "0 20 * * * /opt/backup/backup.sh")|crontab -

La sauvegarde sera déclenchée tous les soirs à 20 heures.

Paramétrer l’identification dans elab

Créer un compte d’administration

Connectez-vous à l’application elab : https://SERVERNAME.inrae.fr/register

Suivez les indications pour créer votre compte d’administration.

Activer l’authentification SAML

Depuis une console SSH, dans le serveur, générez un certificat auto-signé et une clé privée, qui sera nécessaire pour activer l’identification :

cd /opt/elabftw
openssl req -newkey rsa:2048 -nodes -keyout private.key -x509 -days 9999 -out cert.crt
Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:.
Locality Name (eg, city) []:.
Organization Name (eg, company) [Internet Widgits Pty Ltd]:INRAE
Organizational Unit Name (eg, section) []:.
Common Name (e.g. server FQDN or YOUR name) []:SERVERNAME.inrae.fr
Email Address []:

Dans l’interface web de l’application, activez le panneau SYSADMIN (menu en haut à droite), puis positionnez-vous dans l’onglet SAML. Renseignez les informations suivantes :

activer l’authentification SAML : oui
Mode strict : oui
Mode de débogage : non
URL de base : https://SERVERNAME.inrae.fr
EntityID : https://SERVERNAME.inrae.fr
Assertion Consumer Service binding : POST
Single Logout Service Binding : Redirect
NameIDFormat : conservez la valeur par défaut
x509 Certificate in PEM : insérez le contenu du fichier obtenu par cat /opt/elabftw/cert.crt
x509 Certificate private key : insérez le contenu du fichier obtenu par cat /opt/elabftw/private.key
Rollover x509 Certificate in PEM format : c’est le contenu du fichier cert.crt
Dans les paramètres des équipes, n’activez que :
- Créer une équipe envoyée par l’IDP si elle n’existe pas déjà. Cette valeur vous permettra de créer des équipes à la volée (une par unité). Si vous ne souhaitez pas que des utilisateurs d’autres unités puissent se connecter, n’activez pas cette option
- Si vous activez la création automatique des équipes, vous pouvez également activer Si l’utilisateur n’existe pas encore, créer l’utilisateur à la volée
Dans les paramètres de sécurité, activez :
- Sign the samlp:AuthnRequest messages sent (authnRequestSigned)
- Sign the samlp:logoutRequest messages sent (logoutRequestSigned)
- Sign the samlp:logoutResponse messages sent (logoutresponsesigned)
- Sign the metadata (signMetadata)
- Require the samlp:Response to be signed (wantMessagesSigned)
- Require the saml:Assertion to be signed (wantAssertionsSigned)
- Validate all received xmls (strict mode must be activated) (wantXMLValidation)
Dans Liste des fournisseurs d’identité, cliquez sur le bouton Ajouter un nouvel IDP (ajout manuel) et renseignez les informations suivantes :
- Nom convivial : INRAE
- EntityId : https://authentification.inrae.fr/saml/metadata/idp
- Single Sign-On URL : https://authentification.inrae.fr/saml/singleSignOn
- Single Sign-On binding : Redirect
- Single Log Out URL : https://authentification.inrae.fr/saml/singleLogout
- Single Log Out binding (only Redirect is supported) : Redirect
- x509 certificate et x509 Certificate (additional for rollover) : sauf précision contraire, indiquez :

Rajoutez ensuite ces attributs :

What attribute to look for the email : mail
What attribute to look for the firstname : givenName
What attribute to look for the lastname : sn
What attribute to look for the team name : supannEntiteAffectationPrincipale

Une fois ces informations renseignées, cliquez sur le bouton Afficher les métadonnées.xml, et sauvegardez-les dans un fichier sur votre poste de travail (metadata.xml).

Faites une demande d’identification SAML à partir de Ariane : https://ariane.inrae.fr/block?id=ariane_sc_cat_item&sys_id=5c4c1b7a37d002006da398a543990ed2 Vous devrez remplir le Formulaire de demande de rattachement SSO pour le protocole SAML et fournir le fichier metadata.xml que vous avez généré précédemment.

Une fois que votre IDP aura été validée, faites un test de connexion depuis un navigateur en mode “privé” (pour éviter de conserver une identification préalable), et vérifiez que vous arrivez bien à vous connecter.

Puis :

connectez-vous alors avec votre compte “sysadmin”
attribuez les droits sysadmin à votre compte INRAE
désactivez le formulaire d’identification classique en allant dans l’onglet serveur, et en décochant Activer l’authentification locale.

Mesures de sécurité complémentaires dans l’application

A FAIRE : L’activation de l’identification 2FA ne fonctionne pas avec l’identification SAML, c’est à la DSI d’activer cette fonctionnalité.

Mettre à jour l’application

Avant de réaliser l’opération

Assurez-vous de disposer d’un snapshot récent de la machine, à demander le cas échéant l’assistance (cf. supra).

Réalisez également une sauvegarde des données avant de lancer tout mise à jour :

/opt/backup/backup.sh
cat /opt/backup/elabftw-backup.log

Lancez la procédure de mise à jour

cd /opt/elabftw
docker compose pull
docker container stop elabftw
docker compose up -d

Mettez à jour la base de données :

docker exec -it elabftw bin/console db:update

Mettre à jour le certificat

Générer une nouvelle clé et une nouvelle demande

Documentation de référence : Installation d’un certificat

cd /etc/ssl/web/elab.eabx.inrae.fr
 openssl req -new -newkey rsa:2048 -nodes -keyout  elab2023.key -out elab2023.csr
Generating a RSA private key
..........+++++
....................................................................................+++++
writing new private key to 'elab2023.key'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:.
Locality Name (eg, city) []:.
Organization Name (eg, company) [Internet Widgits Pty Ltd]:INRAE
Organizational Unit Name (eg, section) []:.
Common Name (e.g. server FQDN or YOUR name) []:elab.eabx.inrae.fr
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:

Récupérez le fichier elab2023.csr, et intégrez-le dans le formulaire Ariane de demande de certificat Certificats de sécurité pour les serveurs.

Intégrer le certificat

Recopiez le fichier fourni par Ariane (elab_sandbox_inrae_fr_cert.cer) :

cd /etc/ssl/web/SERVERNAME.inrae.fr
cp /home/USERNAME/elab_sandbox_inrae_fr_cert.cer .
mv fullchain.pem fullchain.2022.pem
mv privkey.pem privkey.2022.pem
mv elab2023.key privkey.pem
mv elab_eabx_inrae_fr_cert.cer fullchain.pem

Vous pouvez vérifier la concordance des fichiers avec l’affichage du modulo de la clé privée et du certificat, le modulo devant être identique pour les deux fichiers :

openssl rsa -noout -modulus -in privkey.pem
openssl x509 -noout -modulus -in fullchain.pem

Redémarrez le serveur web

systemctl reload apache2
systemctl status apache2

Connectez-vous à l’application, et vérifiez la date d’expiration du certificat.