Open WebUI : gérer les accès aux documents

Dès qu'une instance Open WebUI sert à plusieurs services, la question n'est plus seulement « le modèle répond-il bien ? » mais « qui peut interroger quels documents ? ». Open WebUI : gérer les accès aux documents passe par trois mécanismes (rôles, groupes, visibilité de chaque base de connaissances) qui se combinent d'une façon pas toujours intuitive. Ce guide explique ce modèle, propose une procédure d'isolation par groupe, puis une méthode pour tester chaque compte séparément et chercher les recoupements. Il ne promet pas d'étanchéité globale : seule une partie du parcours a été observée par la rédaction, et c'est indiqué.
#Pourquoi cloisonner les documents dans Open WebUI
Une base de connaissances (Knowledge) d'Open WebUI est une collection de fichiers découpés en passages et indexés. Quand un utilisateur la cite avec # dans le chat, ou qu'elle est rattachée à un modèle, Open WebUI va chercher les passages proches de la question et les injecte dans le contexte. Le modèle peut alors restituer ces passages, parfois mot pour mot.
Conséquence directe : avoir accès à une base, c'est pouvoir en lire le contenu, même sans jamais ouvrir le fichier. Sur une instance d'équipe, mélanger dans une seule base les procédures publiques, les fiches de paie et les contrats fournisseurs revient à donner tous ces documents à toute personne qui peut l'interroger. Le cloisonnement se fait donc base par base, et non fichier par fichier : un document sensible doit vivre dans une base dont le périmètre d'accès correspond à sa sensibilité.
L'auto-hébergement règle la question du transfert vers un fournisseur externe, pas celle des accès internes. Les guides du site sur le RGPD rappellent que le principe de minimisation s'applique aussi aux collègues : une personne ne devrait accéder qu'aux données nécessaires à sa mission.
#Rôles, groupes et visibilité des bases
Tes documents, ton IA : un RAG local fiable sur tes PDF, notes et mails — sans rien envoyer dans le cloud.
- Espace en ligne à vie
- PDF + fichiers
- Remboursé 30 j
Le contrôle d'accès d'Open WebUI repose sur trois couches. Les confondre est la première source d'erreurs.
- Les rôles
- Chaque compte a un rôle : administrateur, utilisateur, ou en attente (pending). Un compte en attente ne peut rien faire tant qu'un administrateur ne l'a pas validé. Un administrateur gère l'instance et, avec les réglages par défaut, voit le contenu de l'espace de travail des autres comptes. Le rôle est donc une barrière grossière : il sépare ceux qui administrent de ceux qui utilisent.
- Les groupes
- Créés dans le panneau d'administration (section Utilisateurs > Groupes), ils servent à deux choses : porter des permissions fonctionnelles (pouvoir créer des bases, partager, utiliser certaines fonctions) et servir de cible quand on partage une ressource. Un utilisateur peut appartenir à plusieurs groupes.
- La visibilité d'une ressource
- Chaque base de connaissances, comme chaque modèle personnalisé, prompt ou outil, a un réglage d'accès. Privée : seul son propriétaire (et les administrateurs, selon le réglage décrit plus bas) y accède, plus les groupes explicitement ajoutés. Publique : tous les utilisateurs de l'instance peuvent la lire. Pour chaque groupe ajouté, on choisit en général la lecture ou l'écriture.
L'isolation par groupe consiste donc à garder les bases privées, puis à ajouter uniquement le ou les groupes concernés, en lecture pour la plupart des membres. L'écriture (ajouter, remplacer, supprimer des fichiers) se réserve à quelques personnes, idéalement via un groupe distinct des lecteurs.
#Des droits qui s'additionnent : le piège des permissions par défaut
D'après la documentation officielle, les permissions d'Open WebUI sont cumulatives : un utilisateur obtient l'union des permissions par défaut (celles qui s'appliquent à tous les utilisateurs) et de celles de tous ses groupes. La permission la plus large l'emporte. Il n'existe pas de groupe « interdiction » qui retirerait un droit accordé ailleurs.
Deux conséquences pratiques. D'abord, si les permissions par défaut autorisent une action (par exemple partager publiquement une base), aucun groupe ne peut la retirer à un utilisateur : il faut restreindre le défaut, puis rouvrir l'action pour les seuls groupes qui en ont besoin. Ensuite, l'appartenance à un groupe supplémentaire ne peut qu'élargir les accès. Ajouter une personne au groupe « Direction » sans la retirer de « Stagiaires » lui donne les deux périmètres.
- Permissions par défaut
- À régler en premier, au plus restrictif raisonnable : pas de partage public, création de bases limitée si l'instance n'est pas un bac à sable.
- Permissions de groupe
- Rouvrent des fonctions pour un sous-ensemble : un groupe « Éditeurs documentation » qui peut créer et partager des bases, par exemple.
- Accès par ressource
- Indépendant des permissions fonctionnelles : pouvoir créer des bases ne donne pas accès aux bases des autres. C'est le réglage de chaque base qui décide qui la lit.
#Prérequis
- Une instance Open WebUI à jour
- Installée et reliée à Ollama (par défaut sur http://localhost:11434), avec un modèle d'embeddings fonctionnel. Le guide « Open WebUI avec Ollama : guide complet » couvre l'installation.
- Une sauvegarde vérifiée
- Réorganiser les accès, c'est modifier des bases utilisées au quotidien. Archivez le volume Docker avant de commencer (voir « Restaurer Open WebUI et Ollama après une panne »).
- Une cartographie des documents
- Un tableau simple : quelle base, quels documents, quelle sensibilité, quels services doivent lire, qui doit écrire. Sans lui, le paramétrage se fait au fil des demandes et dérive.
- Des comptes de test
- Au moins un compte non administrateur par groupe à vérifier, plus un compte membre d'aucun groupe. Les tests faits avec un compte administrateur ne prouvent rien sur les accès des utilisateurs.
- Les clés d'API autorisées
- Pour les tests en ligne de commande, l'administrateur doit autoriser les clés d'API (réglages d'administration) ; chaque compte de test en génère une depuis Réglages > Compte.
#Gérer les accès aux documents dans Open WebUI : 5 étapes
- 011. Restreindre les permissions par défautDans le panneau d'administration, ouvrez les permissions par défaut des utilisateurs. Désactivez le partage public des bases de connaissances et des modèles, et limitez la création de bases si elle n'est pas nécessaire à tous. Vérifiez aussi le rôle attribué aux nouveaux inscrits : « en attente » évite qu'un compte créé par erreur accède immédiatement à quoi que ce soit.
- 022. Créer les groupesUn groupe par périmètre documentaire (« RH », « Comptabilité », « Support »), plus, si besoin, un groupe d'éditeurs par périmètre. Nommez-les comme les bases correspondantes : la relecture des réglages en sera plus simple. Si vos groupes viennent d'un annuaire via OAuth ou LDAP, vérifiez dans la documentation de votre version comment la synchronisation des groupes est configurée, et si un groupe retiré côté annuaire l'est aussi côté Open WebUI.
- 033. Créer ou réorganiser les basesDans Espace de travail > Connaissances, une base par périmètre. Déplacer un document sensible d'une base large vers une base restreinte suppose de le retirer explicitement de la première : un fichier importé dans deux bases existe deux fois, avec deux réglages d'accès.
- 044. Régler l'accès de chaque baseLaissez la base en privé, ajoutez le groupe concerné en lecture, et le groupe d'éditeurs en écriture. Évitez d'ajouter des personnes une à une : l'accès individuel se perd lors des départs et changements de poste, alors qu'un groupe se tient à jour en un seul endroit.
- 055. Contrôler les modèles qui portent des basesUn modèle personnalisé (Espace de travail > Modèles) peut avoir des bases rattachées. Réglez l'accès du modèle au moins aussi strictement que celui des bases qu'il porte, et testez ce cas en particulier (voir la section sur les recoupements).
#Tester les accès de chaque utilisateur séparément
L'interface d'administration montre ce qui est configuré, pas ce qu'un utilisateur obtient réellement. Le seul contrôle probant consiste à se placer dans la peau de chaque compte. Deux méthodes complémentaires : une fenêtre de navigation privée par compte de test (pour voir les listes et le chat comme l'utilisateur), et des appels à l'API avec la clé de chaque compte (pour obtenir des codes HTTP reproductibles et datés).
Le script ci-dessous interroge, pour chaque compte de test, la liste des bases visibles puis une base précise, et journalise les codes de réponse. Les clés sont lues dans des fichiers privés, une par compte, jamais passées en clair dans la commande. Les routes /api/v1/knowledge/ sont celles de l'API d'Open WebUI ; confirmez-les sur votre version. Le port 3000 correspond à la commande Docker la plus courante (-p 3000:8080).
Un code 200 sur la base signifie que le compte peut la lire par l'API ; un code 401 ou 403 signifie un refus. Le code de la liste est en général 200 pour tout compte valide : c'est son contenu qui compte. La commande suivante affiche les noms des bases visibles par un compte ; selon la version, la réponse est un tableau ou un objet contenant un tableau, d'où le filtre qui gère les deux cas.
Construisez ensuite une matrice : une ligne par compte, une colonne par base, la valeur attendue (lecture, écriture, rien) et la valeur observée. Toute case où l'observé est plus large que l'attendu est un défaut à corriger avant d'importer des documents réels. Rejouez la matrice après chaque mise à jour d'Open WebUI et après chaque modification de groupe : un réglage correct aujourd'hui peut être modifié par une migration ou une erreur de manipulation.
#Recoupements à vérifier
Refuser l'accès direct à une base ne suffit pas à prouver qu'un compte ne peut pas en obtenir le contenu. Plusieurs chemins indirects existent dans une instance Open WebUI ; leur comportement dépend de la version et de la configuration, et aucun n'a été testé par la rédaction. Ce sont des hypothèses à éprouver avec le document témoin, pas des failles constatées.
- Modèle avec base rattachée
- Un utilisateur qui a accès à un modèle personnalisé portant une base, mais pas à la base elle-même : obtient-il les passages de la base en discutant avec le modèle ? Testez en posant au modèle une question sur la phrase témoin.
- Référence directe par identifiant
- L'API de complétion accepte une liste de fichiers ou de collections à utiliser comme contexte. Un compte non autorisé qui connaît l'identifiant d'une base peut-il la citer ainsi ? Voir l'appel de test ci-dessous.
- Conversations partagées
- Une conversation partagée par lien contient les réponses déjà générées, donc potentiellement des extraits de documents. Le lien peut circuler hors du groupe. Vérifiez qui peut créer des liens de partage et ce que voit un compte qui l'ouvre.
- Fichiers joints au chat
- Un document glissé dans une conversation n'est pas une base de connaissances et n'obéit pas aux mêmes réglages. Un utilisateur du groupe RH qui joint une fiche de paie dans une conversation partagée annule le cloisonnement.
- Accès des administrateurs
- Par défaut, les administrateurs voient les ressources des autres comptes. La documentation mentionne une variable d'environnement (BYPASS_ADMIN_ACCESS_CONTROL) pour changer ce comportement ; vérifiez son nom et son effet sur votre version. Dans tous les cas, un administrateur garde l'accès au serveur et à la base de données : limitez le nombre de comptes administrateurs.
- Groupes hérités de l'annuaire
- Avec une synchronisation OAuth ou LDAP, un départ ou un changement de service doit se refléter dans les groupes. Testez le cas d'un compte retiré d'un groupe côté annuaire, après sa reconnexion.
Si la chaîne témoin apparaît, la base fuit par ce chemin : retirez la base des modèles accessibles à ce compte et signalez le comportement au projet avec votre numéro de version. Si elle n'apparaît pas, le test est seulement négatif pour cette version, ce modèle et ce compte. Un modèle peut aussi refuser de répondre ou reformuler : examinez la réponse complète, et pas seulement la recherche de la chaîne.
#Dépannage
- Un utilisateur ne voit pas une base partagée avec son groupe
- Vérifiez qu'il est bien membre du groupe (et non d'un groupe homonyme), puis qu'il s'est reconnecté. Ouvrez une nouvelle conversation : la liste proposée avec # est construite à l'ouverture.
- Un utilisateur voit une base qu'il ne devrait pas voir
- Cherchez dans l'ordre : base passée en publique, groupe large ajouté par erreur, appartenance à un second groupe, permission par défaut trop large. Le cumul des droits fait que la cause est presque toujours un ajout, pas un retrait manquant.
- Le test API répond 401 pour tous les comptes
- Clés d'API désactivées par l'administrateur, clé copiée avec un espace, ou mauvaise URL. Testez d'abord le compte administrateur sur une base qu'il possède.
- Les tests passent en API mais le chat montre la base
- Comparez avec le même compte en navigation privée, sans session administrateur ouverte dans le même navigateur. Un test fait par erreur avec une session admin est la cause la plus fréquente de faux résultats.
- Après mise à jour, les réglages ont changé
- Les migrations peuvent renommer ou réorganiser les permissions. Rejouez la matrice complète et relisez les notes de version de la release installée.
#Ce qui a été vérifié, et ce qui ne l'a pas été
Le 30/10/2026, la rédaction a lancé une image Docker d'Open WebUI isolée, sans accès réseau ni GPU, avec deux comptes factices. Une base de connaissances privée et vide, créée par le compte administrateur, a été demandée par l'API : réponse HTTP 200 pour l'administrateur, HTTP 401 pour le compte utilisateur. C'est la seule observation directe de ce guide. La version exacte de l'image n'est pas reprise ici.
N'ont pas été testés : une base contenant des documents, les groupes et le partage par groupe, les droits d'écriture, le partage public, les modèles portant une base, la référence directe par identifiant, les conversations partagées, la synchronisation de groupes par annuaire, ni un audit complet de l'instance. Les scripts de ce guide sont fournis comme méthode ; leurs résultats sur votre instance sont les seuls qui comptent. Aucun volume de recherche n'a été mesuré pour la requête visée.
#Pour aller plus loin
- Open WebUI avec Ollama : guide complet
- Installation, comptes et réglages de base de l'interface : https://quelllm.fr/guide/open-webui-ollama-tutoriel
- Déployer un chatbot IA pour son équipe sur intranet
- Reverse proxy, authentification et exploitation d'une instance multi-utilisateurs : https://quelllm.fr/guide/deployer-chatbot-ia-equipe-intranet
- RAG local avec Ollama sans coder
- Fonctionnement des bases de connaissances côté interface : https://quelllm.fr/guide/rag-local-ollama-sans-coder
- Source primaire
- Open WebUI, documentation officielle, Authentication & Access > RBAC > Permissions : https://docs.openwebui.com/features/authentication-access/rbac/permissions/ (non relue le 20/11/2026 ; vérifier sur la version installée).
Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.