Installer Open WebUI sur un VPS Linux avec Docker : une interface ChatGPT auto-hebergee

Open WebUI : une interface ChatGPT auto-hebergee sur votre serveur

Open WebUI est une plateforme open source (licence MIT) ecrite en Python qui fournit une interface web de type ChatGPT pour interagir avec des modeles de langage. Le projet prend en charge les modeles locaux servis par Ollama, les API compatibles OpenAI (GPT-4o, o1) et les API Anthropic (Claude). En auto-hebergement sur un VPS Linux, vous gardez le controle total sur vos conversations, vos donnees et vos couts d'utilisation : aucun intermediaire, aucune limite imposee par un service tiers. Contrairement aux solutions SaaS, les requetes envoyees aux modeles transitent uniquement par votre serveur.

Open WebUI gere nativement les comptes multi-utilisateurs avec des roles (administrateur, utilisateur), l'historique des conversations, le partage de prompts, l'upload de fichiers pour le RAG (Retrieval-Augmented Generation) et les appels vocaux en temps reel. La version 0.12 (octobre 2026) ajoute les appels vocaux avec avatar 3D, l'authentification multi-facteur, les groupes avec modeles par defaut et l'historique de versions des outils. L'application fonctionne sur tout systeme Unix ou Linux disposant de Docker, et peut aussi tourner sous Windows via Docker Desktop.

Ce tutoriel couvre le deploiement d'Open WebUI via Docker sur un VPS Linux sous Ubuntu 22.04/24.04 ou Debian 12, la connexion a un serveur Ollama local ou distant, la configuration du serveur web en reverse proxy (Nginx ou Apache) pour l'acces HTTPS, la gestion de la base de donnees, le firewall et l'administration multi-utilisateurs.

Prerequis

• Un VPS Linux (serveur virtuel) avec au minimum 2 Go de RAM et 1 vCPU pour Open WebUI seul. L'image standard consomme environ 300 Mo de RAM au repos. Si vous executez Ollama sur le meme serveur pour l'inference locale, prevoyez au minimum 8 Go de RAM et 4 vCPU selon le modele utilise.
• Docker Engine v25 ou superieur installe sur le serveur. Si Docker n'est pas encore configure, suivez notre guide installer Docker sur un VPS Linux.
• Un nom de domaine (ou un sous-domaine) pointe vers l'adresse IP publique du VPS via un enregistrement DNS de type A. Ce domaine sera utilise pour la configuration HTTPS.
• Un acces shell au serveur : connexion SSH root ou un nom d'utilisateur avec les droits sudo. Sur un poste sous Windows, utilisez un client SSH comme PuTTY ou le terminal Windows (voir notre guide configurer l'acces a un VPS depuis Windows avec PuTTY et WinSCP).

Deployer Open WebUI avec Docker en ligne de commande

Open WebUI publie ses images Docker sur le registre GitHub Container Registry (ghcr.io). L'installation la plus simple utilise une seule commande docker run dans le shell. Commencez par generer une cle secrete pour signer les sessions utilisateur :

openssl rand -hex 32

Copiez la chaine generee (elle servira de valeur pour la variable WEBUI_SECRET_KEY), puis lancez le conteneur :

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  -e WEBUI_SECRET_KEY=votre-cle-secrete-ici \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Details des parametres de cette commande :

• -p 3000:8080 : expose le port TCP 3000 sur le VPS. Le conteneur ecoute en interne sur le port 8080. Vous pouvez verifier les ports en ecoute avec ss -tlnp (voir notre guide lister les ports en ecoute sur Linux).
• --add-host=host.docker.internal:host-gateway : permet au conteneur d'atteindre les services de l'hote (utile pour un serveur Ollama installe directement sur le VPS).
• -v open-webui:/app/backend/data : persiste la base de donnees SQLite, les conversations et les configurations dans un volume Docker nomme. Ce repertoire contient aussi les fichiers uploades pour le RAG.
• WEBUI_SECRET_KEY : cle de signature des sessions. Sans cette variable d'environnement, la cle change a chaque redemarrage du conteneur et deconnecte tous les utilisateurs.

L'image :main (environ 1,6 Go) est l'image standard recommandee pour la production. Elle embarque les packages Python necessaires au RAG, a la transcription vocale et aux modeles d'embedding. Open WebUI propose aussi des variantes :

Verifiez que le conteneur tourne correctement en consultant les logs :

docker ps --filter name=open-webui
docker logs open-webui --tail 20

Les logs doivent afficher le demarrage du serveur Python (Uvicorn) sur le port 8080. L'interface est alors accessible sur http://ADRESSE-IP-DU-VPS:3000 dans votre navigateur.

Premier login et creation du compte admin

Ouvrez l'adresse IP de votre VPS dans un navigateur (port 3000). La page de login s'affiche avec un formulaire d'inscription. Le premier utilisateur qui cree un compte devient automatiquement l'administrateur de l'instance. Choisissez un nom d'utilisateur, une adresse email et un mot de passe solide.

Pour automatiser la creation du compte admin sans passer par le formulaire (utile dans un script de deploiement), ajoutez ces variables d'environnement au lancement du conteneur :

-e WEBUI_ADMIN_EMAIL=admin@exemple.com \
-e WEBUI_ADMIN_PASSWORD=un-mot-de-passe-fort \
-e WEBUI_ADMIN_NAME=Admin

Une fois connecte au panneau d'administration (icone en haut a droite), vous pouvez configurer les connexions aux modeles, gerer les utilisateurs et ajuster les reglages de l'instance. L'interface admin permet aussi de consulter les logs d'activite et de definir le role par defaut des nouveaux inscrits (DEFAULT_USER_ROLE : pending, user ou admin).

Connecter Open WebUI a Ollama

Open WebUI peut se connecter a un serveur Ollama pour utiliser des modeles de langage locaux (Llama, Mistral, Gemma, Phi). Deux configurations se presentent selon l'architecture de votre infrastructure.

Ollama sur le meme VPS

Si Ollama est installe directement sur le VPS hote, Open WebUI le detecte automatiquement via l'adresse host.docker.internal (grace au parametre --add-host configure au lancement). Aucune configuration supplementaire n'est necessaire : les modeles disponibles apparaissent dans le selecteur de l'interface.

Verifiez que le serveur Ollama repond depuis le conteneur :

docker exec open-webui curl -s http://host.docker.internal:11434/api/tags

La commande doit renvoyer la liste des modeles installes au format JSON. Si la requete echoue, verifiez qu'Ollama ecoute bien sur toutes les interfaces (OLLAMA_HOST=0.0.0.0 dans la configuration du serveur Ollama).

Ollama sur un serveur distant

Si Ollama tourne sur un autre serveur (par exemple un serveur dedie avec GPU), configurez la variable d'environnement OLLAMA_BASE_URL au lancement du conteneur :

docker run -d -p 3000:8080 \
  -v open-webui:/app/backend/data \
  -e WEBUI_SECRET_KEY=votre-cle-secrete-ici \
  -e OLLAMA_BASE_URL=http://IP-SERVEUR-OLLAMA:11434 \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Sur le serveur Ollama distant, assurez-vous que le port TCP 11434 est accessible uniquement depuis l'adresse IP du VPS Open WebUI. Configurez le firewall avec UFW :

sudo ufw allow from IP-VPS-OPENWEBUI to any port 11434 proto tcp

Pour securiser cette communication entre les deux serveurs, utilisez un reverse proxy Nginx avec TLS sur le serveur Ollama, ou un tunnel WireGuard (voir notre guide WireGuard sur VPS Linux).

Connecter des API externes (OpenAI, Anthropic)

Open WebUI ne necessite pas Ollama pour fonctionner. Vous pouvez connecter directement les API OpenAI ou Anthropic depuis le panneau d'administration, sans installer de package supplementaire :

1. Connectez-vous a Open WebUI avec le compte administrateur.
2. Ouvrez Panneau d'administration puis Connexions.
3. Dans la section API OpenAI, ajoutez l'URL du endpoint (https://api.openai.com/v1) et votre cle API. Les protocoles utilises sont HTTPS pour le transport et WebSocket pour le streaming des reponses.
4. Pour Anthropic, ajoutez une connexion avec l'URL https://api.anthropic.com/v1 et votre cle API.

Les modeles disponibles apparaissent automatiquement dans le selecteur. Vous pouvez combiner des modeles locaux (Ollama) et des API distantes dans la meme instance. Les administrateurs peuvent aussi restreindre l'acces a certains modeles par groupe d'utilisateurs, ce qui permet de controler les couts des requetes API.

Deploiement avec Docker Compose

Pour un deploiement plus structure et reproductible, utilisez un fichier compose.yaml. Cette approche facilite les mises a jour et centralise les variables d'environnement dans un fichier de config separe. Si vous decouvrez Docker Compose, consultez notre guide Docker Compose sur VPS Linux.

Creez un repertoire de travail et les fichiers de configuration depuis le shell :

mkdir -p ~/open-webui && cd ~/open-webui

Creez le fichier compose.yaml avec votre editeur de texte (nano, vim) :

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    restart: always
    ports:
      - "127.0.0.1:3000:8080"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui-data:/app/backend/data
    environment:
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
      - WEBUI_URL=https://chat.exemple.com

volumes:
  open-webui-data:

Creez un fichier .env dans le meme repertoire pour stocker les variables sensibles. Ce fichier ne doit jamais etre versionne dans Git :

WEBUI_SECRET_KEY=votre-cle-secrete-generee-avec-openssl

Lancez la pile et consultez les logs pour verifier le demarrage :

docker compose up -d
docker compose logs -f open-webui

Notez que le port est ici configure en 127.0.0.1:3000:8080 (ecoute locale uniquement). Le conteneur n'est pas accessible directement depuis Internet : seul le serveur web (Nginx ou Apache) sur le meme VPS peut le joindre, ce qui renforce la securite.

Mettre en HTTPS avec un reverse proxy Nginx

En production, exposez Open WebUI derriere un serveur web configure en reverse proxy avec un certificat TLS. Nginx est le choix le plus courant pour cette configuration. Si Nginx n'est pas installe, suivez notre guide configurer Nginx en reverse proxy sur VPS Linux. Obtenez un certificat avec Certbot et Let's Encrypt.

Creez le fichier de configuration du virtual host Nginx :

sudo nano /etc/nginx/sites-available/open-webui

Configuration du reverse proxy Nginx :

server {
    listen 80;
    server_name chat.exemple.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name chat.exemple.com;

    ssl_certificate /etc/letsencrypt/live/chat.exemple.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/chat.exemple.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    client_max_body_size 50M;

    access_log /var/log/nginx/open-webui-access.log;
    error_log /var/log/nginx/open-webui-error.log;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        proxy_read_timeout 1800;
        proxy_send_timeout 1800;
        proxy_buffering off;
        proxy_cache off;
    }
}

Points importants de cette configuration du serveur web :

• proxy_buffering off et proxy_cache off : indispensables pour que le streaming des reponses du modele fonctionne correctement. Sans ces directives, les reponses arrivent en bloc au lieu de s'afficher mot par mot dans l'interface.
• proxy_http_version 1.1 avec les en-tetes Upgrade et Connection : active le protocole WebSocket, necessaire pour les appels vocaux et le streaming temps reel.
• proxy_read_timeout 1800 : timeout de 30 minutes pour les completions longues. Les modeles locaux peuvent mettre plusieurs minutes a generer une reponse complete.
• client_max_body_size 50M : autorise l'upload de fichiers volumineux pour le RAG (documents PDF, fichiers texte).
• access_log et error_log : chemins des fichiers de log Nginx pour diagnostiquer les erreurs de connexion. Pensez a configurer la rotation des journaux pour eviter que les logs ne remplissent le disque.

Activez le site, testez la configuration et rechargez le serveur web :

sudo ln -s /etc/nginx/sites-available/open-webui /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Apres avoir configure le certificat TLS avec Certbot, Open WebUI est accessible sur https://chat.exemple.com. Ajoutez la variable WEBUI_URL=https://chat.exemple.com dans la configuration du conteneur pour que les liens internes et l'authentification OAuth fonctionnent correctement.

Alternative : reverse proxy avec Apache

Si votre VPS utilise deja Apache comme serveur web (par exemple via un panel comme Plesk), vous pouvez l'utiliser a la place de Nginx. Activez les modules necessaires en ligne de commande :

sudo a2enmod ssl proxy proxy_http proxy_wstunnel headers rewrite
sudo systemctl restart apache2

Creez un fichier de configuration pour le virtual host Apache :

sudo nano /etc/apache2/sites-available/open-webui.conf

Configuration Apache avec support WebSocket :

<VirtualHost *:443>
    ServerName chat.exemple.com

    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/chat.exemple.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/chat.exemple.com/privkey.pem

    ProxyPreserveHost On
    ProxyTimeout 1800
    LimitRequestBody 52428800

    RewriteEngine On
    RewriteCond %{HTTP:Upgrade} websocket [NC]
    RewriteCond %{HTTP:Connection} upgrade [NC]
    RewriteRule ^/?(.*) ws://127.0.0.1:3000/$1 [P,L]

    ProxyPass / http://127.0.0.1:3000/
    ProxyPassReverse / http://127.0.0.1:3000/

    ErrorLog ${APACHE_LOG_DIR}/open-webui-error.log
    CustomLog ${APACHE_LOG_DIR}/open-webui-access.log combined
</VirtualHost>

Activez le site et rechargez Apache :

sudo a2ensite open-webui.conf
sudo apachectl configtest
sudo systemctl reload apache2

Le module proxy_wstunnel est indispensable pour le protocole WebSocket utilise par Open WebUI pour le streaming des reponses et les appels vocaux. Sans ce module, les requetes WebSocket echouent et l'interface affiche les reponses d'un bloc au lieu de les diffuser en temps reel.

Gestion multi-utilisateurs et controle d'acces

Le premier utilisateur inscrit devient automatiquement administrateur. Les utilisateurs suivants recoivent le role defini par la variable DEFAULT_USER_ROLE (par defaut : pending, ce qui signifie qu'un admin doit valider chaque inscription). Les administrateurs peuvent depuis le panneau d'administration :

• Gerer les comptes : creer, desactiver ou supprimer des utilisateurs. Chaque compte a un nom d'utilisateur, une adresse email et un role.
• Definir les modeles accessibles par groupe. Les groupes supportent l'imbrication depuis la version 0.12 : un groupe « equipe-dev » peut heriter des permissions d'un groupe parent.
• Activer ou desactiver l'inscription publique. Par defaut, le formulaire de login permet aux visiteurs de creer un compte.
• Configurer l'authentification externe : OAuth2 (Google, GitHub, Azure AD, Keycloak, Authentik), LDAP ou en-tetes de confiance (Trusted Headers) pour les utilisateurs deja authentifies par un reverse proxy.
• Activer l'authentification multi-facteur (TOTP) pour renforcer la securite des comptes administrateurs.

Pour desactiver l'inscription publique et limiter l'acces a une equipe :

-e ENABLE_SIGNUP=False
-e DEFAULT_USER_ROLE=pending

Pour un acces mono-utilisateur sans page de login, lancez le conteneur avec -e WEBUI_AUTH=False. Ce mode convient a un usage personnel sur un VPS protege par un acces SSH securise et un firewall restrictif.

Configurer la base de donnees

Par defaut, Open WebUI utilise SQLite comme base de donnees (database). Le fichier de base se trouve dans le volume Docker, sous /app/backend/data/webui.db. Cette configuration convient pour un usage mono-serveur avec quelques utilisateurs.

Pour un deploiement en production avec plusieurs utilisateurs simultanes ou une architecture multi-instances, la documentation officielle recommande de migrer vers PostgreSQL. Si PostgreSQL n'est pas encore installe sur votre infrastructure, consultez notre guide installer PostgreSQL sur un VPS Linux.

Configurez la connexion a la base de donnees PostgreSQL via la variable d'environnement DATABASE_URL :

-e DATABASE_URL=postgresql://openwebui:mot-de-passe@127.0.0.1:5432/openwebui

Variables de configuration du pool de connexions pour adapter les performances a la charge :

Open WebUI n'utilise pas MySQL ni MariaDB. Si votre serveur dispose deja d'une instance MySQL (par exemple pour un serveur FiveM), elle ne pourra pas etre reutilisee : le schema de la base de donnees est specifique a PostgreSQL ou SQLite.

Mettre a jour Open WebUI

Les conversations, les comptes et les configurations sont stockes dans le volume Docker open-webui-data. La mise a jour consiste a tirer la nouvelle image et recreer le conteneur. Les donnees du volume persistent entre les mises a jour.

Avec docker run (script de mise a jour en trois commandes) :

docker pull ghcr.io/open-webui/open-webui:main
docker stop open-webui && docker rm open-webui
docker run -d -p 127.0.0.1:3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  -e WEBUI_SECRET_KEY=votre-cle-secrete-ici \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Avec Docker Compose (deux commandes) :

cd ~/open-webui
docker compose pull && docker compose up -d

Verifiez les logs apres chaque mise a jour pour detecter d'eventuelles migrations de la base de donnees :

docker logs open-webui --tail 50

Pour automatiser le nettoyage des anciennes images Docker et recuperer de l'espace disque dans les repertoires de stockage, consultez notre guide nettoyer Docker sur VPS Linux.

Securiser le deploiement

Mesures a appliquer pour un deploiement en production sur votre serveur :

• Restreindre l'ecoute du port 3000 : si le serveur web (Nginx ou Apache) tourne sur le meme VPS, configurez le mapping de port en -p 127.0.0.1:3000:8080. Le conteneur n'est alors accessible que depuis l'hote local, pas directement depuis les adresses IP publiques.
• Configurer le firewall : bloquez le port TCP 3000 en entree avec UFW. Seuls les ports 80 (HTTP) et 443 (HTTPS) doivent etre ouverts sur l'interface publique. Verifiez la configuration du firewall avec sudo ufw status verbose.
• Desactiver l'inscription publique si Open WebUI n'est pas destine a un usage ouvert. Passez ENABLE_SIGNUP=False dans les variables d'environnement.
• Sauvegarder le volume Docker regulierement. La base de donnees (SQLite ou PostgreSQL) et les fichiers uploades se trouvent dans /app/backend/data. Un script de sauvegarde minimal :

docker cp open-webui:/app/backend/data ./backup-open-webui-$(date +%Y%m%d)
# Envoyez ensuite le repertoire vers un stockage distant (NAS, S3, serveur de sauvegarde)
# Voir notre guide : sauvegarder un VPS avec rsync

Automatisez cette sauvegarde avec une tache cron pour ne jamais perdre vos donnees. Pour un transfert securise des fichiers de sauvegarde, privilegiez SFTP (via SSH) plutot que FTP, qui transmet les identifiants en clair sur le reseau.

• Surveiller les ressources du serveur avec htop ou btop, surtout si Ollama tourne sur le meme VPS. L'inference locale consomme enormement de RAM et de CPU.
• Proteger le serveur SSH contre les tentatives de connexion avec Fail2ban pour bloquer les adresses IP qui echouent plusieurs fois a se connecter.

Recapitulatif des variables d'environnement

Open WebUI se configure principalement via des variables d'environnement passees au conteneur Docker. Voici les principales, classees par categorie :

La liste complete des variables de configuration est disponible dans la documentation officielle d'Open WebUI. Ces reglages peuvent aussi etre modifies depuis le panneau d'administration une fois l'instance configuree.

Questions frequentes

Retrouvez ci-dessous les reponses aux questions les plus courantes sur l'installation et la configuration d'Open WebUI sur un VPS Linux.