Open WebUI Azure: Der komplette Leitfaden 2026

Q: Funktioniert das auch in Azure Germany West Central statt West Europe?

Ja, einfach `location = 'germanywestcentral'` in `main.tf` setzen. Azure OpenAI ist in Germany West Central seit 2024 mit GPT-4o und GPT-4.1 verfügbar, die Latenz liegt 10-15 ms über West Europe. Für Kunden mit strikter Data-Residency-Anforderung (Versicherungsaufsicht, Betriebsrat) der sauberste Weg.

Q: Wie halte ich Open WebUI aktuell?

Das Image `ghcr.io/open-webui/open-webui:main` folgt dem Release-Branch. Updates holen Sie mit `docker compose pull && docker compose up -d`. Wir empfehlen, nicht auf `main` zu laufen, sondern auf `:v0.6.x` festzunageln und monatlich zu patchen — dann landet kein Breaking Change ungeplant in Produktion. Das Backend-Volume (`./open-webui-backend`) muss täglich gesichert werden, dort liegen alle Chats, Prompts und Nutzereinstellungen.

Pexon Consulting | 14 Min. Lesezeit | 26.11.2025

TL;DR

Open WebUI Azure ist die DSGVO-konforme Alternative zu ChatGPT Enterprise: Sie hosten die Chat-Oberfläche selbst, nutzen Azure OpenAI als Modell-Backend und binden Ihre Mitarbeiter per SSO aus Entra ID an. Pexon Consulting (80 Mitarbeiter, Microsoft Partner) betreibt dieses Setup produktiv bei Kunden in Versicherung, Fertigung und Energie. Zeitaufwand für die Ersteinrichtung: rund drei Stunden.

Vergleich	ChatGPT Enterprise	Open WebUI auf Azure
Kosten pro Nutzer (200 MA)	60 USD / User / Monat	~1,50 EUR / User / Monat Infrastruktur + Token-Verbrauch
Datenverarbeitung	OpenAI USA (mit DPA)	Azure West Europe / Germany West Central
SSO	Nur ab Enterprise-Plan	Entra ID ab Tag 1
Modell-Wechsel	Nur OpenAI-Modelle	GPT-4.1, Claude via Azure, eigene Llama-Modelle

Warum Open WebUI Azure statt ChatGPT Enterprise

ChatGPT Enterprise kostet 60 USD pro Nutzer und Monat. Bei 200 Mitarbeitern sind das 144.000 USD im Jahr — ohne dass Sie die Kontrolle über Speicherort, Modelle oder Feinsteuerung haben.

Open WebUI ist eine Open-Source-Chat-Oberfläche mit über 131.000 GitHub-Stars. Kombiniert mit Azure OpenAI bekommen Sie die gleiche Funktionalität wie ChatGPT Enterprise — aber in Ihrem Azure-Tenant, mit Ihren Compliance-Einstellungen und zu einem Bruchteil der Kosten.

Wir raten nicht pauschal jedem zum Eigenbetrieb. Wenn Sie unter 50 Mitarbeiter haben und keine regulatorischen Anforderungen, ist ChatGPT Enterprise mit Admin-Panel der schnellere Weg. Ab 200+ Mitarbeitern, mit einem Betriebsrat oder in regulierten Branchen kippt die Rechnung — und zwar deutlich.

Was Sie am Ende haben werden

Eine produktionsreife Open-WebUI-Installation auf einer Azure-VM
Single Sign-On über Ihr bestehendes Microsoft Entra ID
Automatisches SSL-Zertifikat via Let’s Encrypt, verlängert sich selbst
Integration mit Azure OpenAI (GPT-4.1 im Beispiel, andere Modelle möglich)
Eine Infrastructure-as-Code-Basis mit Terraform, die Sie versionieren, kopieren und im Disaster Recovery wiederherstellen können

Wichtig: Der erste Nutzer, dessen E-Mail mit WEBUI_ADMIN_EMAIL übereinstimmt, erhält beim ersten Login automatisch Admin-Rechte. Das ist kein Bug — das ist das Bootstrap-Pattern von Open WebUI.

Voraussetzungen

Bevor wir starten, brauchen Sie:

Azure-Abonnement mit Rechten zum Anlegen von Ressourcen (Contributor auf Subscription- oder Resource-Group-Ebene reicht)
Eine Domain oder Subdomain, die Sie auf die Azure-VM zeigen können (z.B. ai.ihrefirma.de)
Terraform lokal installiert (mindestens 1.7)
Azure CLI installiert und mit az login authentifiziert
SSH-Key-Paar in ~/.ssh/id_rsa.pub und ~/.ssh/id_rsa
Grundkenntnisse Kommandozeile, Azure, Linux

Zeitaufwand: 2-3 Stunden für die komplette Ersteinrichtung.

Teil 1: Azure-Infrastruktur mit Terraform

Terraform ermöglicht es, die komplette Infrastruktur als Code zu definieren. Wir deployen damit: Resource Group, VNet, Subnet, Public IP, NSG mit SSH/HTTP/HTTPS, eine Ubuntu-VM und den Azure-OpenAI-Service inklusive GPT-4.1-Deployment.

1.1 Terraform-Dateien anlegen

Erstellen Sie ein Projektverzeichnis und zwei Dateien.

providers.tf — Azure Provider konfigurieren. Ersetzen Sie SUBSCRIPTION_ID_HIER mit Ihrer Azure-Subscription-ID (bekommen Sie via az account show --query id -o tsv):

variable "subscription_id" {
  default = "SUBSCRIPTION_ID_HIER"
}

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "=4.37.0"
    }
  }
}

provider "azurerm" {
  features {
    resource_group {
      prevent_deletion_if_contains_resources = false
    }
  }
  subscription_id = var.subscription_id
}

main.tf — die eigentliche Infrastruktur. Das ist der längste Teil, dafür läuft danach alles mit einem Befehl:

variable "location"            { default = "westeurope" }
variable "admin_username"      { default = "azureuser" }
variable "ssh_public_key_path" { default = "~/.ssh/id_rsa.pub" }

# Resource Group
resource "azurerm_resource_group" "main" {
  name     = "rg-openwebui"
  location = var.location
}

# Network
resource "azurerm_virtual_network" "main" {
  name                = "vnet-openwebui"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
}

resource "azurerm_subnet" "main" {
  name                 = "subnet-openwebui"
  resource_group_name  = azurerm_resource_group.main.name
  virtual_network_name = azurerm_virtual_network.main.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_public_ip" "main" {
  name                = "pip-openwebui"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  allocation_method   = "Static"
}

# Security
resource "azurerm_network_security_group" "main" {
  name                = "nsg-openwebui"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name

  security_rule {
    name                       = "SSH"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }

  security_rule {
    name                       = "HTTP"
    priority                   = 110
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }

  security_rule {
    name                       = "HTTPS"
    priority                   = 120
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "443"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

resource "azurerm_network_interface" "main" {
  name                = "nic-openwebui"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.main.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.main.id
  }
}

resource "azurerm_network_interface_security_group_association" "main" {
  network_interface_id      = azurerm_network_interface.main.id
  network_security_group_id = azurerm_network_security_group.main.id
}

# VM
resource "azurerm_linux_virtual_machine" "main" {
  name                            = "vm-openwebui"
  resource_group_name             = azurerm_resource_group.main.name
  location                        = azurerm_resource_group.main.location
  size                            = "Standard_B4ms"
  admin_username                  = var.admin_username
  disable_password_authentication = true
  network_interface_ids           = [azurerm_network_interface.main.id]

  admin_ssh_key {
    username   = var.admin_username
    public_key = file(var.ssh_public_key_path)
  }

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
    disk_size_gb         = 100
    name                 = "osdisk-vm-openwebui"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "ubuntu-24_04-lts"
    sku       = "server"
    version   = "latest"
  }
}

# Azure OpenAI
resource "random_string" "suffix" {
  length  = 6
  special = false
  upper   = false
}

resource "azurerm_cognitive_account" "openai" {
  name                  = "openai-${random_string.suffix.result}"
  location              = azurerm_resource_group.main.location
  resource_group_name   = azurerm_resource_group.main.name
  kind                  = "OpenAI"
  sku_name              = "S0"
  custom_subdomain_name = "openai-${random_string.suffix.result}"
}

resource "azurerm_cognitive_deployment" "gpt4" {
  name                 = "gpt-4"
  cognitive_account_id = azurerm_cognitive_account.openai.id

  model {
    format  = "OpenAI"
    name    = "gpt-4.1"
    version = "2025-04-14"
  }

  sku {
    name     = "GlobalStandard"
    capacity = 5000
  }
}

# Outputs
output "public_ip"              { value = azurerm_public_ip.main.ip_address }
output "ssh_command"            { value = "ssh ${var.admin_username}@${azurerm_public_ip.main.ip_address}" }
output "openai_endpoint"        { value = azurerm_cognitive_account.openai.endpoint; sensitive = true }
output "openai_key"             { value = azurerm_cognitive_account.openai.primary_access_key; sensitive = true }
output "openai_deployment_name" { value = azurerm_cognitive_deployment.gpt4.name }

VM-Größe im Blick behalten: Standard_B4ms (4 vCPU, 16 GB RAM, burstable) kostet in West Europe rund 120 EUR/Monat und reicht für 50-100 aktive Nutzer locker aus. Wenn Sie Open WebUI als reinen Frontend-Proxy vor Azure OpenAI nutzen — also ohne lokale Embeddings oder Ollama-Modelle — geht auch ein Standard_B2ms.

1.2 Infrastruktur deployen

terraform init
terraform plan  -out=tf.plan
terraform apply     tf.plan

Nach 4-6 Minuten ist alles da. Notieren Sie sich die Ausgabewerte:

# Öffentliche IP der VM
terraform output public_ip

# Azure OpenAI Endpunkt
terraform output -raw openai_endpoint

# Azure OpenAI API-Key
terraform output -raw openai_key

# Deployment-Name (gpt-4)
terraform output openai_deployment_name

DNS-Eintrag jetzt setzen: Erstellen Sie einen A-Record von ai.ihrefirma.de auf die öffentliche IP. Ohne funktionierenden DNS-Eintrag wird Let’s Encrypt später kein Zertifikat ausstellen — das ist der häufigste Fehler in Schritt 3.

Teil 2: SSO mit Microsoft Entra ID konfigurieren

Single Sign-On ist der Grund, warum Open WebUI überhaupt enterprise-tauglich wird. Ihre Mitarbeiter melden sich mit ihrem Microsoft-365-Konto an, Sie steuern Zugriffe über Sicherheitsgruppen, und das Offboarding läuft automatisch mit.

2.1 App-Registrierung erstellen

Azure Portal → Microsoft Entra ID → App-Registrierungen → Neue Registrierung.

Feld	Wert
Name	Open WebUI
Unterstützte Kontotypen	Nur Konten in diesem Organisationsverzeichnis
Umleitungs-URI (Web)	`https://ai.ihrefirma.de/oauth/microsoft/callback`

Nach dem Erstellen notieren Sie drei Werte von der Übersichtsseite:

Anwendungs-ID → später MICROSOFT_CLIENT_ID
Verzeichnis-ID → später MICROSOFT_CLIENT_TENANT_ID
Umleitungs-URI → später MICROSOFT_REDIRECT_URI

2.2 Client Secret erstellen

Zertifikate & Geheimnisse → Neuer geheimer Clientschlüssel.

Empfehlung: Gültigkeit auf 24 Monate setzen, nicht 6. Wir haben bei einem Kunden erlebt, dass ein 6-Monats-Secret an einem Freitagabend abgelaufen ist und 200 Mitarbeiter am Montag nicht arbeiten konnten. Das Secret bei der Erstellung sofort kopieren — es wird danach nie wieder angezeigt.

2.3 API-Berechtigungen setzen

API-Berechtigungen → Berechtigung hinzufügen → Microsoft Graph → Delegierte Berechtigungen:

openid
profile
email

Danach: Administratorzustimmung für [Tenant] erteilen. Ohne diesen Klick bekommen normale Nutzer beim ersten Login einen Fehler, weil sie die Berechtigungen nicht selbst bestätigen dürfen.

2.4 Sicherheitsgruppe anlegen

Nicht jeder im Unternehmen braucht Zugriff auf das KI-Tool. Legen Sie eine Sicherheitsgruppe an, über die Sie den Zugang steuern.

Microsoft Entra → Gruppen → Neue Gruppe:

Typ: Sicherheit
Name: OpenWebUI-Users
Mitglieder hinzufügen (oder dynamische Mitgliedschaft nach Abteilung)

Dann zurück zur App-Registrierung: Verwaltete Anwendung in lokalem Verzeichnis → Benutzer und Gruppen → Gruppe zuweisen. Aktivieren Sie unter Eigenschaften der Enterprise Application die Option „Zuweisung erforderlich?“ — nur dann greift die Gruppenbeschränkung wirklich.

Teil 3: Server einrichten

Jetzt verbinden wir uns mit der VM und konfigurieren Docker, Open WebUI, Nginx und Let’s Encrypt.

3.1 Mit der VM verbinden

ssh azureuser@<öffentliche-ip-aus-schritt-1.2>

3.2 Docker installieren

# System aktualisieren
sudo apt update && sudo apt upgrade -y

# Neustart für Kernel-Updates
sudo reboot
# warten, dann wieder verbinden
ssh azureuser@

# Docker installieren
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

# Neu anmelden damit die Gruppe wirkt
exit
ssh azureuser@

# Testen
docker ps

3.3 Eigenen Benutzer für Open WebUI

Wir lassen die Anwendung nicht unter azureuser, sondern unter einem eigenen Service-User laufen. Principle of Least Privilege:

sudo adduser openwebui
sudo usermod -aG docker openwebui
su - openwebui
docker ps   # muss ohne sudo funktionieren

3.4 Konfigurations-Struktur anlegen

mkdir -p ~/openwebui/openwebui-deployment/nginx/{conf,templates}
mkdir -p ~/openwebui/openwebui-deployment/nginx/certbot/{www,conf}
cd ~/openwebui/openwebui-deployment

docker-compose.yml

services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    user: "${HOST_UID}:${HOST_GID}"
    restart: always
    ports:
      - "8080:8080"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      - WEBUI_URL=https://${DOMAIN}
      - ENABLE_LOGIN_FORM=${ENABLE_LOGIN_FORM}
      - WEBUI_NAME=${WEBUI_NAME}
      - ENABLE_DIRECT_CONNECTIONS=${ENABLE_DIRECT_CONNECTIONS}
      - ENABLE_EVALUATION_ARENA_MODELS=${ENABLE_EVALUATION_ARENA_MODELS}
      - ENABLE_API_KEY=${ENABLE_API_KEY}
      - JWT_EXPIRES_IN=${JWT_EXPIRES_IN}
      - OFFLINE_MODE=${OFFLINE_MODE}
      - CORS_ALLOW_ORIGIN=${CORS_ALLOW_ORIGIN}
      - ENABLE_OAUTH_SIGNUP=${ENABLE_OAUTH_SIGNUP}
      - OAUTH_MERGE_ACCOUNTS_BY_EMAIL=${OAUTH_MERGE_ACCOUNTS_BY_EMAIL}
      - MICROSOFT_CLIENT_TENANT_ID=${MICROSOFT_CLIENT_TENANT_ID}
      - MICROSOFT_CLIENT_ID=${MICROSOFT_CLIENT_ID}
      - MICROSOFT_CLIENT_SECRET=${MICROSOFT_CLIENT_SECRET}
      - MICROSOFT_REDIRECT_URI=${MICROSOFT_REDIRECT_URI}
      - OAUTH_GROUP_CLAIM=${OAUTH_GROUP_CLAIM}
      - ENABLE_OAUTH_GROUP_MANAGEMENT=${ENABLE_OAUTH_GROUP_MANAGEMENT}
      - ENABLE_OAUTH_GROUP_CREATION=${ENABLE_OAUTH_GROUP_CREATION}
      - WEBUI_SESSION_COOKIE_SECURE=${WEBUI_SESSION_COOKIE_SECURE}
      - WEBUI_AUTH_COOKIE_SECURE=${WEBUI_AUTH_COOKIE_SECURE}
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
    volumes:
      - ./open-webui-backend:/app/backend/data

  nginx:
    image: nginx:latest
    restart: always
    ports:
      - "80:80"
      - "443:443"
    environment:
      - DOMAIN=${DOMAIN}
    volumes:
      - ./nginx/templates/:/etc/nginx/templates/
      - ./nginx/conf/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/certbot/www/:/var/www/certbot/
      - ./nginx/certbot/conf/:/etc/letsencrypt/
    depends_on:
      - openwebui

  certbot:
    image: certbot/certbot:latest
    depends_on:
      - nginx
    command: >-
      certonly --reinstall --webroot --webroot-path=/var/www/certbot
      --email ${EMAIL} --agree-tos --no-eff-email -d ${DOMAIN}
    volumes:
      - ./nginx/certbot/conf/:/etc/letsencrypt/
      - ./nginx/certbot/www/:/var/www/certbot/

.env

Erstellen Sie ~/openwebui/openwebui-deployment/.env:

# Microsoft Entra SSO
MICROSOFT_CLIENT_TENANT_ID=
MICROSOFT_CLIENT_ID=
MICROSOFT_CLIENT_SECRET=
MICROSOFT_REDIRECT_URI=https://ai.ihrefirma.de/oauth/microsoft/callback

# Open WebUI
WEBUI_NAME=Mein-WebUI
CORS_ALLOW_ORIGIN=https://ai.ihrefirma.de
WEBUI_SECRET_KEY=<32 Zeichen Zufalls-String: openssl rand -hex 16>
ENABLE_LOGIN_FORM=false
ENABLE_OAUTH_SIGNUP=true
OAUTH_MERGE_ACCOUNTS_BY_EMAIL=true
ENABLE_DIRECT_CONNECTIONS=true
ENABLE_EVALUATION_ARENA_MODELS=false
ENABLE_API_KEY=true
JWT_EXPIRES_IN=5h
OFFLINE_MODE=true
OAUTH_GROUP_CLAIM=groups
ENABLE_OAUTH_GROUP_MANAGEMENT=true
ENABLE_OAUTH_GROUP_CREATION=true
WEBUI_SESSION_COOKIE_SECURE=true
WEBUI_AUTH_COOKIE_SECURE=true

# Nginx / Let's Encrypt
DOMAIN=ai.ihrefirma.de
EMAIL=it-admin@ihrefirma.de

# Azure OpenAI
AZURE_API_KEY=
AZURE_API_BASE=
AZURE_API_DEPLOYMENT=gpt-4
AZURE_API_VERSION=2024-12-01-preview

Wichtig — diese Werte müssen präzise passen:

Variable	Woher	Beispiel
`MICROSOFT_CLIENT_TENANT_ID`	Schritt 2.1	`0aa3807e-f2fc-44b4-84d5-16a30bc6ed98`
`MICROSOFT_CLIENT_ID`	Schritt 2.1	`e8f9a123-...`
`MICROSOFT_CLIENT_SECRET`	Schritt 2.2	`%Z~8?!T4BDIO...`
`MICROSOFT_REDIRECT_URI`	Schritt 2.1	`https://ai.ihrefirma.de/oauth/microsoft/callback`
`DOMAIN`	Ihre Domain, ohne `https://`	`ai.ihrefirma.de`
`WEBUI_SECRET_KEY`	`openssl rand -hex 16`	32-Zeichen Hex
`AZURE_API_KEY`	Schritt 1.2	API-Key aus Azure OpenAI
`AZURE_API_BASE`	Schritt 1.2	`https://openai-xxxxx.openai.azure.com`
`AZURE_API_DEPLOYMENT`	Schritt 1.2	`gpt-4`

Nginx: Basis-Config

~/openwebui/openwebui-deployment/nginx/conf/nginx.conf:

worker_processes 1;

events {
    worker_connections 1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    server_names_hash_bucket_size 128;
    sendfile      on;
    keepalive_timeout 65;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/templates/*.conf.template;
}

Nginx: Template für Let’s Encrypt Bootstrap

~/openwebui/openwebui-deployment/nginx/templates/app.conf.template:

server {
    listen 80;
    listen [::]:80;
    server_name ${DOMAIN};

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 200 "Waiting for SSL setupn";
        add_header Content-Type text/plain;
    }
}

Jetzt Nginx temporär starten, um das Zertifikat zu beantragen:

docker compose up -d nginx

Test, ob der Webserver erreichbar ist:

curl http://ai.ihrefirma.de
# Erwartung: "Waiting for SSL setup"

curl http://ai.ihrefirma.de/.well-known/acme-challenge/test
# Erwartung: HTTP 404 (Pfad existiert, Datei nicht)

Wenn beides so aussieht, Zertifikat holen:

docker compose run --rm certbot

Prüfen, ob das Zertifikat da ist:

ls -la nginx/certbot/conf/live/ai.ihrefirma.de/
# sollte fullchain.pem, privkey.pem, chain.pem, cert.pem zeigen

Nginx: Template mit SSL-Redirect

Jetzt app.conf.template ersetzen:

server {
    listen 80;
    listen [::]:80;
    server_name ${DOMAIN};

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name ${DOMAIN};

    ssl_certificate     /etc/letsencrypt/live/${DOMAIN}/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/${DOMAIN}/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    location ~ /.well-known/acme-challenge {
        allow all;
        root /var/www/certbot;
    }

    location / {
        proxy_pass http://openwebui:8080;
        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;
    }
}

Config testen und alles starten:

docker compose exec nginx nginx -t
docker compose down
HOST_UID=$(id -u) HOST_GID=$(id -g) docker compose up -d

Öffnen Sie https://ai.ihrefirma.de im Browser — Sie werden zur Login-Seite von Open WebUI mit der Option „Mit Microsoft anmelden“ weitergeleitet. Der erste Login mit einer Admin-E-Mail macht den Nutzer automatisch zum Administrator.

Azure OpenAI in Open WebUI verbinden

Nach dem ersten Admin-Login: Admin-Panel → Settings → Connections → OpenAI API.

Feld	Wert
API Base URL	`https://openai-xxxxx.openai.azure.com/openai/deployments/gpt-4`
API Key	Ihr `AZURE_API_KEY`
API Type	`azure`
API Version	`2024-12-01-preview`

Speichern, Modell-Liste neu laden — gpt-4 erscheint als verfügbares Modell. Ab jetzt chatten Ihre Mitarbeiter mit GPT-4.1 über Ihren Azure-Tenant, mit Ihren Audit-Logs und Ihren DSGVO-Einstellungen.

Wann sich der Eigenbetrieb lohnt — und wann nicht

Unsere klare Empfehlung nach Kundenprojekten in Versicherung, Fertigung und Energie:

Lohnt sich: ab 100 aktiven Nutzern, mit SSO-Pflicht, bei sensiblen Daten (HR, Kundendaten, Konstruktionsunterlagen) oder wenn Sie ohnehin auf Azure OpenAI umsteigen müssen. Die 3-4 Stunden Ersteinrichtung amortisieren sich im ersten Monat.

Lohnt sich nicht: unter 50 Nutzern ohne Compliance-Anforderungen. Der Betriebsaufwand (Patches, Monitoring, Updates) übersteigt dann die Lizenzersparnis. Nehmen Sie ChatGPT Business oder Microsoft Copilot.

Pexon Consulting

Sie wollen wissen, wie das konkret für Ihr Unternehmen aussehen kann?

Jetzt persönliche Beratung vereinbaren

Kostenfreie Erstberatung

Häufig gestellte Fragen

Was kostet der Betrieb von Open WebUI auf Azure monatlich?

Für 100-200 Nutzer rechnen Sie mit rund 150-180 EUR Infrastruktur (VM + Public IP + Storage) plus dem variablen Azure-OpenAI-Token-Verbrauch. Bei durchschnittlicher Nutzung (5-10 Anfragen pro Nutzer pro Tag) landen die Token-Kosten bei 300-800 EUR/Monat. Gesamt also 450-1.000 EUR statt 12.000 EUR für ChatGPT Enterprise bei 200 Mitarbeitern.

Open WebUI Azure vs. ChatGPT Enterprise — was ist der ehrliche Unterschied?

ChatGPT Enterprise ist schneller aufgesetzt, hat ein besseres Mobile-Erlebnis und die OpenAI-eigenen Features (Canvas, Operator) kommen zuerst dort an. Open WebUI gibt Ihnen dafür volle Kontrolle über Modelle (auch Claude, Llama, eigene Embeddings), Daten bleiben in Ihrem Azure-Tenant, und die Kosten skalieren mit Verbrauch statt mit Nutzerzahl. Für regulierte Branchen ist Open WebUI fast immer die richtige Wahl.

Funktioniert das auch in Azure Germany West Central statt West Europe?

Ja, einfach location = "germanywestcentral" in main.tf setzen. Azure OpenAI ist in Germany West Central seit 2024 mit GPT-4o und GPT-4.1 verfügbar, die Latenz liegt 10-15 ms über West Europe. Für Kunden mit strikter Data-Residency-Anforderung (Versicherungsaufsicht, Betriebsrat) der sauberste Weg.

Wie migriere ich bestehende ChatGPT-Nutzer auf Open WebUI?

Nutzer können ihren bisherigen Chatverlauf aus ChatGPT exportieren und in Open WebUI importieren. Wichtiger ist der Systemumstieg: Kommunizieren Sie 2-3 Wochen vorher, bieten Sie ein 30-Minuten-Webinar an und lassen Sie Super-User in jeder Abteilung die Ersteinarbeitung übernehmen. Wir haben bei einem Versicherer 600 Nutzer in 4 Wochen migriert — der entscheidende Hebel war nicht das Tool, sondern ein gemeinsamer Prompt-Katalog für wiederkehrende Aufgaben.

Wie halte ich Open WebUI aktuell?

Das Image ghcr.io/open-webui/open-webui:main folgt dem Release-Branch. Updates holen Sie mit docker compose pull && docker compose up -d. Wir empfehlen, nicht auf main zu laufen, sondern auf :v0.6.x festzunageln und monatlich zu patchen — dann landet kein Breaking Change ungeplant in Produktion. Das Backend-Volume (./open-webui-backend) muss täglich gesichert werden, dort liegen alle Chats, Prompts und Nutzereinstellungen.

Nächster Schritt

Sie wollen Open WebUI auf Azure aufsetzen, aber ohne die 20 Edge Cases selbst zu erwischen (Shared Image Gallery, Private Endpoints, Group Claims mapping)? Wir haben dieses Setup in unterschiedlichen Varianten bei rund einem Dutzend Kunden deployt und können es in einem fixen Rahmen bei Ihnen produktiv stellen.

Zum 6-Wochen-Pilotprojekt Generative AI

Pexon Open WebUI auf Azure

Schlüsselfertig statt 20 Edge Cases selbst lösen

Shared Image Gallery, Private Endpoints, Group-Claims-Mapping, GPU-Sizing — wir haben dieses Setup bei rund einem Dutzend Kunden produktiv gestellt. Wir bauen Ihre Open-WebUI-Plattform auf Azure in einem fixen Rahmen auf und binden RAG auf Ihre Unternehmensdokumente an.

Open WebUI schlüsselfertig auf Azure → RAG-Chatbot auf Azure →

Open WebUI auf Azure: Der komplette Leitfaden 2026

TL;DR

Warum Open WebUI Azure statt ChatGPT Enterprise

Was Sie am Ende haben werden

Voraussetzungen

Teil 1: Azure-Infrastruktur mit Terraform

1.1 Terraform-Dateien anlegen

1.2 Infrastruktur deployen

Teil 2: SSO mit Microsoft Entra ID konfigurieren

2.1 App-Registrierung erstellen

2.2 Client Secret erstellen

2.3 API-Berechtigungen setzen

2.4 Sicherheitsgruppe anlegen

Teil 3: Server einrichten

3.1 Mit der VM verbinden

3.2 Docker installieren

3.3 Eigenen Benutzer für Open WebUI

3.4 Konfigurations-Struktur anlegen

docker-compose.yml

.env

Nginx: Basis-Config

Nginx: Template für Let’s Encrypt Bootstrap

Nginx: Template mit SSL-Redirect

Azure OpenAI in Open WebUI verbinden

Wann sich der Eigenbetrieb lohnt — und wann nicht

Sie wollen wissen, wie das konkret für Ihr Unternehmen aussehen kann?

Häufig gestellte Fragen

Nächster Schritt

Verwandte Themen

Kategorien

Neueste Beiträge

Branchen

Lösungen

Technologien

Unternehmen

Ressourcen

Kontakt

Open WebUI auf Azure: Der komplette Leitfaden 2026

TL;DR

Warum Open WebUI Azure statt ChatGPT Enterprise

Was Sie am Ende haben werden

Voraussetzungen

Teil 1: Azure-Infrastruktur mit Terraform

1.1 Terraform-Dateien anlegen

1.2 Infrastruktur deployen

Teil 2: SSO mit Microsoft Entra ID konfigurieren

2.1 App-Registrierung erstellen

2.2 Client Secret erstellen

2.3 API-Berechtigungen setzen

2.4 Sicherheitsgruppe anlegen

Teil 3: Server einrichten

3.1 Mit der VM verbinden

3.2 Docker installieren

3.3 Eigenen Benutzer für Open WebUI

3.4 Konfigurations-Struktur anlegen

docker-compose.yml

.env

Nginx: Basis-Config

Nginx: Template für Let’s Encrypt Bootstrap

Nginx: Template mit SSL-Redirect

Azure OpenAI in Open WebUI verbinden

Wann sich der Eigenbetrieb lohnt — und wann nicht

Sie wollen wissen, wie das konkret für Ihr Unternehmen aussehen kann?

Häufig gestellte Fragen

Nächster Schritt

Verwandte Themen

Mehr Blogartikel wie dieser

AKS-Fehler 2026: was 30 Klicks im Portal verschweigen

Business Central mit KI entwickeln: AL und Claude Code

Kundenreferenz: Azure KI-Plattform in 18 Monaten

Kategorien

Neueste Beiträge