Skip to content

Documentation

Prérequis

  • OS : Debian 12 (LTS)
  • Configuration matérielle
Type Nombre de coeurs RAM Disque
minimale 4 16 50 Go
recommandée 6 24 50 Go
idéale 8 32 50 Go
  • Accès aux vues Siham et Apogée ou autre mode de versement
  • CAS
    • Nom de domaine autorisé
    • Attributs permettant de faire le lien entre utilisateur CAS et personnel Siham
Attribut Pattern
mail prenom.nom@nom-de-domaine.fr
displayName Prenom Nom
givenName Prenom
eduPersonPrincipalName nom@nom-de-domaine.fr
sn Nom

Eléments de contexte à rassembler

Variable d'environnement Description
<WORKDIR> chemin de déploiement (ex. /usr/src/labrri)
<CERTFILE> nom du certfile du certificat
<KEYFILE nom du keyfile du certificat
<LOGIN> login de l'utilisateur Linux dédié
<UID> id de l'utilisateur Linux dédié
<GID> id du groupe de l'utilisateur Linux dédié
<IP> adresse IP du système hôte
<DOMAINE> ex. labri.univ-tours.fr
<MOTDEPASSE_TRAEFIK_BCRYPT> mot de passe d'accès au dashboard de Traefik encodé en BCrypt, veiller à échapper le caractère $ (remplacer tout $ par $$)
<NOMBDD_POSTGRES> nom de la base de données PostgreSQL
<UTILISATEUR_POSTGRES> utilisateur de la base de données PostgreSQL
<MOTDEPASSE_POSTGRES> mot de passe de l'utilisateur de la base de données PostgreSQL
<NOMCONTENEUR_POSTGRES> nom du conteneur labri-db-3 instancié (ex. labrri_labri-db-3_1)
<IMAGE_DB> nom/path de l'image du conteneur labri-db-3 à instancier
<IMAGE_PHP> nom/path de l'image du conteneur labri-php à instancier
<IMAGE_ADMIN> nom/path de l'image du conteneur labri-admin à instancier
<IMAGE_ORGASEARCH> nom/path de l'image du conteneur labri-orgasearch à instancier
<CLE_OPENALEX> clé API OpenAlex (optionnel, pour le service OrgaSearch)
<CLE_API_PARTNERS> clé X-Api-Key pour GET /api/partners si l’instance doit être partageable comme source OrgaSearch (≥ 32 caractères)
<DOSSIER_BACKUP> chemin du dossier de sauvegarde de la base de données (ex. /usr/src/backup_db)
<DOSSIER_LOGS> chemin du dossier de logs de la sauvegarde de la base de données (ex. /usr/src/backup_log)
<SECRET_CUBE> lettres et chiffres, au moins 32 caractères
<DOMAINE_CAS> ex. : cas.univ-tours.fr
<SECRET_SYMFONY> lettres et chiffres, au moins 32 caractères
<SECRET_JWT> lettres et chiffres, au moins 32 caractères
<MOTDEPASSE_SUPERADMIN_CLAIR> mot de passe du super administrateur de l'application en clair
<MOTDEPASSE_SUPERADMIN_BCRYPT> mot de passe du super administrateur de l'application encodé en BCrypt
<VUE_SIHAM_COMPOSANTE> ex. : v_appri_cmp
<VUE_SIHAM_SERVICE> ex. : v_appri_service
<VUE_SIHAM_UNITE> ex. : v_appri_unit_rech
<VUE_SIHAM_PERSONNE> ex. : v_appri_pers
<VUE_APOGEE_DIPLOME> ex. : v_appri_diplome
<VUE_APOGEE_ETUDIANT> ex. : v_appri_etu_indiv
<VUE_APOGEE_DOCTORAT> ex. : v_appri_cotu
<VUE_HAL_PUBLICATION> ex. : v_appri_publi
<VUE_HAL_STRUCTURE> ex. : v_appri_struct
<CLE_API_OPENAI> clé API LLM
<URL_API_COMPLETION> point d'entrée API pour la complétion
<URL_API_TRANSCRIPTION> point d'entrée API pour la transcription
<MODELE_TRANSCRIPTION> nom du modèle de transcription
<CODE_ORG_OPENAI> code organisation OpenAI
<UTILISATEUR_SCM> utilisateur ayant accès au dépôt Git
<ACCESS_TOKEN_SCM> token d'accès au registry

Procédure de déploiement

Cette procédure a été validée sous Debian 12.13 avec Docker 29.1.5.

ETAPE 1 : Créer l'utilisateur qui va exécuter la stack

sudo useradd -m <LOGIN>
sudo passwd <LOGIN>
sudo usermod -aG sudo <LOGIN>

ETAPE 2 : Installer Docker

  • Se logger avec l'utilisateur créé précédemment
    su <LOGIN>
    
  • Consulter la marche à suivre via ce lien

ETAPE 3 : Rotation des logs Docker

  • Créer le fichier /etc/docker/daemon.json (en sudo)
  • Y ajouter la configuration suivante
    {
        "log-driver": "json-file",
        "log-opts": {
            "max-size": "10m",
            "max-file": "3",
            "labels": "production_status",
            "env": "os,customer"
        }
    }
    
  • Relancer la service docker
    sudo service docker restart
    

ETAPE 4 : Ajouter l'utilisateur créé précédemment au groupe docker et vérifier que Docker fonctionne

sudo usermod -aG docker <LOGIN>
newgrp docker
docker run hello-world

ETAPE 5 : Cloner le repository

  • Cloner le contenu de labrri-deploy.git dans <WORKDIR>
  • Rendre l'utilisateur dédié propriétaire du dossier <WORKDIR> et de son contenu
    sudo chown -R <LOGIN>:<LOGIN> <WORKDIR>
    

Important

  • Poursuivre en tant qu'utilisateur <LOGIN>
  • Certaines étapes proposent en alternative d'utiliser le script configuration-tool.sh pour exécuter des opérations automatiquement (en mode démo ou de façon effective)
  • Pour utiliser ce script, il faut d'abord le rendre exécutable
    chmod +x <WORKDIR>/configutation-tool.sh
    

ETAPE 6 : Installer le certificat et lancer la stack d'orchestration

  • Exécuter les opérations n° 1 et 2
  • Copier <WORKDIR>/docker/traefik/dynamic/certificates.yml.sample dans <WORKDIR>/docker/traefik/dynamic/certificates.yml
  • Dans le fichier <WORKDIR>/docker/traefik/dynamic/certificates.yml, modifier les éléments de contexte
    <CERTFILE>
    <KEYFILE>
    
  • Se rendre dans le dossier <WORKDIR>/orchestration
  • Copier <WORKDIR>/orchestration/.env.sample dans <WORKDIR>/orchestration/.env et modifier les éléments de contexte
    DOMAIN=<IP>
    PASSWORD=<MOTDEPASSE_TRAEFIK_BCRYPT>
    
  • Copier <WORKDIR>/orchestration/docker-compose.yml.sample dans <WORKDIR>/orchestration/docker-compose.yml
  • Copier le certfile dans <WORKDIR>/docker/traefik/ssl/certs/<CERTFILE>
  • Copier le keyfile dans <WORKDIR>/docker/traefik/ssl/private/<KEYFILE>
  • Se rendre dans le dossier <WORKDIR>/orchestration
  • Lancer la stack en arrière-plan
    docker compose up -d
    
  • Vérifier l'état des conteneurs
    docker compose ps
    

ETAPE 7 : Télécharger les images

  • Se rendre à l'url suivante : http://<IP>/portainer/
  • S'authentifier (utilisateur à créer)
  • Ajouter le registry personnalisé labrri-deploy
    • Registry URL : scm.univ-tours.fr:4567
    • Username : <UTILISATEUR_SCM>
    • Password : <ACCESS_TOKEN_SCM>
  • Depuis labrri-deploy, télécharger les images suivantes (noms fournis par ILIAD3)
    • <IMAGE_DB>
    • <IMAGE_PHP>
    • <IMAGE_ORGASEARCH>

ETAPE 8 : Lancer la stack applicative

  • Exécuter les opérations n° 3, 4 et 5
  • Se rendre dans le dossier <WORKDIR>/docker/php
  • Rendre exécutable le script entrypoint.sh
    chmod +x entrypoint.sh
    
  • Se rendre dans le dossier <WORKDIR>
  • Modifier les variables d'environnement
    • Copier <WORKDIR>/.env.sample dans <WORKDIR>/.env
    • Dans le fichier <WORKDIR>/.env
      • Modifier les éléments de contexte
        LOCAL_USER=<UID>:<GID>
        DOMAIN=<DOMAINE>
        IP=<IP>
        
      • Modifier les identifiants d'accès à la base de données
        POSTGRES_DB_3=<NOMBDD_POSTGRES>
        POSTGRES_USER_3=<UTILISATEUR_POSTGRES>
        POSTGRES_PASSWORD_3=<MOTDEPASSE_POSTGRES>
        
  • Créer le fichier <WORKDIR>/docker/api/.env
  • Copier <WORKDIR>/docker-compose.yml.sample dans <WORKDIR>/docker-compose.yml
  • Copier <WORKDIR>/docker/cron/Dockerfile.sample dans <WORKDIR>/docker/cron/Dockerfile
  • Copier <WORKDIR>/docker/cron/crontab.sample dans <WORKDIR>/docker/cron/crontab

PostgreSQL 18

Le sample monte le volume pg_data_18 sur /var/lib/postgresql (pas .../data). Pour une migration depuis PostgreSQL 15, voir v1.13.0 : conserver le volume pg_data_3 jusqu'à validation.

  • Se rendre dans le dossier <WORKDIR>
  • Dans le fichier <WORKDIR>/.env
    • Modifier les noms des images des conteneurs labri-db-3, labri-php et labri-orgasearch à instancier
      LABRI_DB_IMAGE=<IMAGE_DB>
      LABRI_PHP_IMAGE=<IMAGE_PHP>
      ORGASEARCH_IMAGE=<IMAGE_ORGASEARCH>
      

OrgaSearch (optionnel)

Dans le bloc environment de labri-orgasearch du docker-compose.yml (en complément des variables déjà présentes dans le sample) :

  • OpenAlex : OPENALEX_API_KEY: "<CLE_OPENALEX>"
  • Source LaBRRI Tours (seule source LaBRRI activable en OrgaSearch 0.3.0) : URL (préfixe /api) et clé fournies par l’administrateur de l’instance de l'Université de Tours. Sans ces deux variables, la source reste inactive.
    labri-orgasearch:
        image: ${ORGASEARCH_IMAGE}
        restart: on-failure
        environment:
            ROOT_PATH: /orgasearch
            WIKIDATA_USER_AGENT: "Orgasearch/0.3.0 (labri@univ-tours.fr)"
            # 1 IP partagée (RP) → plafond d'instance, pas par utilisateur
            RATE_LIMIT_SEARCH: "60/minute"
            RATE_LIMIT_GLOBAL: "180/minute"
            RATE_LIMIT_READ: "120/minute"
            OPENALEX_API_KEY: "<CLE_OPENALEX>"
            LABRI_TOURS_API_URL: "https://labri.univ-tours.fr/api"
            LABRI_TOURS_API_KEY: "<CLE_FOURNIE_PAR_L_ADMIN_TOURS>"
        networks:
            - traefik
        labels:
            # ...
    
  • Lancer la stack en arrière-plan
    docker compose up -d
    
  • Vérifier l'état des conteneurs
    docker compose ps
    
  • A ce stade, le conteneur labri-cube redémarre indéfiniment car il n'est pas encore configuré

ETAPE 9 : Vérifier les permissions

  • Exécuter l'opération n° 6
  • Veiller à ce que les dossiers suivants soient créés avec les bons droits (<LOGIN>:<LOGIN> 0755)
    • <WORKDIR>/.cache/api
    • <WORKDIR>/.data/cube
    • <WORKDIR>/.logs/admin
    • <WORKDIR>/.logs/api
    • <WORKDIR>/.logs/symfony
    • <DOSSIER_BACKUP>
    • <DOSSIER_LOGS>

ETAPE 10 : Importer la base de données

  • Se rendre à l'adresse http://<IP>/dbadmin
  • Se connecter à la bdd
    • système : PostgreSQL
    • serveur : labri-db-3
    • utilisateur : <UTILISATEUR_POSTGRES>
    • mot de passe : <MOTDEPASSE_POSTGRES>
    • base de données : <NOMBDD_POSTGRES>
  • Importer le schéma <WORKDIR>/docker/db/dump.sql

ETAPE 11 : Programmer la sauvegarde de la base de données

  • Exécuter l'opération n° 7
  • Se rendre dans le dossier <WORKDIR>
  • Copier <WORKDIR>/save-database.sh.sample dans <WORKDIR>/save-database.sh
  • Rendre exécutable le script shell dédié à la sauvegarde de la bdd
    chmod +x save-database.sh
    
  • Dans le fichier <WORKDIR>/save-database.sh, modifier les éléments de contexte
    find <DOSSIER_BACKUP>/* -mtime +180 -exec rm {} \;
    docker exec <NOMCONTENEUR_POSTGRES> pg_dump -U <UTILISATEUR_POSTGRES> -F t <NOMBDD_POSTGRES> > <DOSSIER_BACKUP>/labri-db-`date +%Y-%m-%d-%H-%M`.tar
    
  • Ouvrir le crontab de l'utilisateur dédié
    sudo crontab -e -u <LOGIN>
    
  • Ajouter la ligne suivante
    22 02 * * * <WORKDIR>/save-database.sh >> <DOSSIER_LOGS>/backup.log 2>&1
    

ETAPE 12 : Configurer le cube de données

  • Exécuter l'opération n° 8
  • Se rendre dans le dossier <WORKDIR>/.data/cube
  • Modifier la configuration
    • Copier <WORKDIR>/docker/cube/.env.sample dans <WORKDIR>/.data/cube/.env
    • Dans le fichier <WORKDIR>/.data/cube/.env
      • Modifier les identifiants de connexion
        CUBEJS_DB_NAME=<NOMBDD_POSTGRES>
        CUBEJS_DB_USER=<UTILISATEUR_POSTGRES>
        CUBEJS_DB_PASS=<MOTDEPASSE_POSTGRES>
        
      • Modifier le secret
        CUBEJS_API_SECRET=<SECRET_CUBE>
        
  • Se rendre à l'url suivante : http://<IP>/portainer/
  • S'authentifier
  • Consulter le conteneur labri-cube
  • Cliquer sur l'action Recreate

ETAPE 13 : Configurer Symfony/API Platform

  • Exécuter les opérations n° 9, 10, 11 et 12
  • Copier <WORKDIR>/docker/api/.env.sample dans <WORKDIR>/docker/api/.env
  • Dans le fichier <WORKDIR>/docker/api/.env
    • Modifier les éléments de contexte
      CAS_HOST=<DOMAINE_CAS>
      CAS_LOGIN_TARGET=https://<DOMAINE>
      CAS_LOGOUT_TARGET=https://<DOMAINE>
      UI_URL='https://<DOMAINE>/ui/admin'
      UI_DOMAIN='<DOMAINE>'
      
    • Modifier le secret de Symfony
      APP_SECRET=<SECRET_SYMFONY>
      
    • Modifier le chemin de connection à la base de données
      DATABASE_3_URL=postgresql://<UTILISATEUR_POSTGRES>:<MOTDEPASSE_POSTGRES>@labri-db-3:5432/<NOMBDD_POSTGRES>
      
    • Modifier le secret JWT
      JWT_PASSPHRASE=<SECRET_JWT>
      
    • Modifier le mot de passe du super administrateur
      • Indiquer un mot de passe encodé en BCrypt
        ADMIN_PASSWORD='<MOTDEPASSE_SUPERADMIN_BCRYPT>'
        
      • Ne pas échapper celui-ci lorsqu'il contient le caractère $
    • Modifier le secret du cube
      CUBE_API_SECRET='<SECRET_CUBE>'
      
    • Renseigner la clé de l'API partenaires si cette instance doit être partageable comme source OrgaSearch (la communiquer ensuite aux administrateurs OrgaSearch concernés ; laisser vide pour laisser l’endpoint inactif)
      PARTNERS_API_KEY='<CLE_API_PARTNERS>'
      
    • Indiquer les éventuelles vues Siham/Apogée
      VIEW_COMPOSANTE='<VUE_SIHAM_COMPOSANTE>'
      VIEW_SERVICE='<VUE_SIHAM_SERVICE>'
      VIEW_UNITE='<VUE_SIHAM_UNITE>'
      VIEW_PERSONNE='<VUE_SIHAM_PERSONNE>'
      VIEW_DIPLOME='<VUE_APOGEE_DIPLOME>'
      VIEW_ETUDIANT='<VUE_APOGEE_ETUDIANT>'
      VIEW_DOCTORAT='<VUE_APOGEE_DOCTORAT>'
      VIEW_PUBLICATION='<VUE_HAL_PUBLICATION>'
      VIEW_STRUCTURE='<VUE_HAL_STRUCTURE>'
      
    • Indiquer le délai (en années) d'anonymisation des enregistrements après la sortie des systèmes d'information externes
      ANON_DELAY=<entier>
      
    • Activer ou non la prise en charge du prompt d'aide à la génération de graphique (voire la commande vocale)
      DASHBOARD_PROMPT=<true|false>
      DASHBOARD_VOCAL=<true|false>
      OPENAI_API_KEY='<CLE_API_OPENAI>'
      OPENAI_ORG='<CODE_ORG_OPENAI>'
      OPENAI_API_COMPLETION_URL='<URL_API_COMPLETION>'
      OPENAI_API_TRANSCRIPTION_URL='<URL_API_TRANSCRIPTION>'
      OPENAI_API_TRANSCRIPTION_MODEL='<MODELE_TRANSCRIPTION>'
      
  • Se rendre dans le dossier <WORKDIR>
  • Exécuter le conteneur PHP
    docker compose exec labri-php bash
    
  • "Dans le conteneur", se rendre dans le dossier /usr/src/api
  • Générer les clés JWT
    php bin/console lexik:jwt:generate-keypair
    
  • Générer un token perpétuel permettant d'accéder aux tableaux de bord/graphiques publiés (et le réserver pour la compilation du client)
    php bin/console app:generate-public-token
    
  • Quitter le conteneur
    exit
    
  • Se rendre dans le dossier <WORKDIR>/.cache/api
  • S'il existe, supprimer le dossier prod
    sudo rm -r prod
    

Complétion/transcription

Il est possible de se procurer une clé d'accès à Albert API, la plateforme interministérielle d'inférence

  • Vérifier que l'url suivante répond : https://<DOMAINE>/api (description de l'API sous Swagger)

ETAPE 14 : Eléments nécessaires à la compilation du client React

  • Fournir les éléments suivants à ILIAD3
    • Token d'accès à l'API Mapbox (https://docs.mapbox.com/help/dive-deeper/access-tokens/)
    • Token perpétuel d'accès au cube de données généré précédemment
    • Adresse du siège de l'université
    • URL d'accès à la politique RGPD de l'université
    • Délai d'anonymisation des enregistrements

ETAPE 15 : Tester le client React (compilé avec les éléments de contexte fournis)

  • Télécharger l'image du conteneur labri-admin (nom fourni par ILIAD3)
  • Dans le fichier <WORKDIR>/.env
    • Modifier le nom de l'image du conteneur labri-admin à instancier
      LABRI_ADMIN_IMAGE=<IMAGE_ADMIN>
      
  • Dans le fichier <WORKDIR>/docker-compose.yml, décommenter le service labri-admin
  • Relancer la stack en arrière-plan
    docker compose up -d
    
  • Vérifier l'état des conteneurs
    docker compose ps
    
  • Vérifer que l'url suivante répond : https://<DOMAINE>/ui
  • Vider le cache navigateur du site et recharger
  • S'authentifier avec le compte super administrateur
    Identifiant : admin
    Mot de passe : <MOTDEPASSE_SUPERADMIN_CLAIR>