> ## Documentation Index
> Fetch the complete documentation index at: https://docs.varios-ai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Update von 2026.08 auf 2026.10

> Schritt-für-Schritt-Anleitung für das Update einer On-Premise-Installation von 2026.08.x auf 2026.10 mit lokalem Code Interpreter und virtuellem Dateisystem

Diese Anleitung führt Sie durch das Update einer On-Premise-Installation von 2026.08.x auf 2026.10. Mit dem Update werden der lokale Code Interpreter und das virtuelle Dateisystem zum festen Bestandteil; dafür ergänzen Sie `.env` und `docker-compose.yml` von Hand. Außerdem bezieht VARIOS AI die Images ab 2026.10 aus der Container-Registry `registry.varios-ai.com` statt aus `aibroker.azurecr.io`.

`<ZIELVERSION>` steht für `2026.10` oder einen späteren Patch-Stand `2026.10.x`, den Ihnen das VARIOS AI-Team nennt. Als Installationsverzeichnis wird im Beispiel `/docker/variosai` verwendet.

## A. Vorab (vor dem Wartungsfenster)

1. Lassen Sie sich vom VARIOS AI-Team bestätigen, dass `<ZIELVERSION>` veröffentlicht ist.
2. Prüfen Sie Plattenplatz und Arbeitsspeicher:
   ```bash theme={null}
   df -h /var/lib/docker        # >= 10 GB frei
   free -h                      # >= 1,5 GB frei für Sandbox-Reserve
   ```
3. Übertragen Sie die Anmeldung auf die neue Container-Registry. Die bisherigen Zugangsdaten gelten auch für `registry.varios-ai.com`. Der folgende Befehl liest die für `aibroker.azurecr.io` gespeicherte Anmeldung aus und meldet sich damit an `registry.varios-ai.com` an. Er benötigt `python3`. Führen Sie ihn mit `sudo -H` aus, denn der Update-Dienst `varios-update.service` läuft als `root` und verwendet die Anmeldung von `root`. Wenn Sie `docker` auch als eigener Benutzer ohne `sudo` aufrufen, führen Sie den Befehl zusätzlich ohne `sudo -H` aus:
   ```bash theme={null}
   sudo -H python3 - <<'PY'
   import base64, json, os, subprocess
   from pathlib import Path

   old, new = "aibroker.azurecr.io", "registry.varios-ai.com"
   config_dir = Path(os.environ.get("DOCKER_CONFIG", Path.home() / ".docker"))
   cfg = json.loads((config_dir / "config.json").read_text())

   helper = cfg.get("credHelpers", {}).get(old) or cfg.get("credsStore")
   if helper:
       result = subprocess.run([f"docker-credential-{helper}", "get"], input=old, capture_output=True, text=True)
       if result.returncode != 0:
           raise SystemExit(f"Keine gespeicherte Anmeldung für {old} gefunden.")
       creds = json.loads(result.stdout)
       user, password = creds["Username"], creds["Secret"]
   else:
       auth = cfg.get("auths", {}).get(old, {}).get("auth")
       if not auth:
           raise SystemExit(f"Keine gespeicherte Anmeldung für {old} gefunden.")
       user, password = base64.b64decode(auth).decode().split(":", 1)

   if user == "<token>":
       raise SystemExit(f"Für {old} ist nur ein Token gespeichert. Melden Sie sich mit Benutzername und Passwort an.")

   subprocess.run(["docker", "login", new, "--username", user, "--password-stdin"], input=password, text=True, check=True)
   PY
   ```
   Die Ausgabe endet mit `Login Succeeded`. Bricht der Befehl ab, melden Sie sich mit den Zugangsdaten vom VARIOS AI-Team direkt an:
   ```bash theme={null}
   sudo docker login registry.varios-ai.com
   ```

## B. gVisor installieren (optional, empfohlen)

1. Installieren Sie `runsc` nach der offiziellen Anleitung und registrieren Sie es als Docker-Runtime: [Installation](https://gvisor.dev/docs/user_guide/install/) und [Docker Quick Start](https://gvisor.dev/docs/user_guide/quick_start/docker/).
2. Führen Sie den dort beschriebenen Docker-Neustart **erst im Wartungsfenster** aus, da er alle Container neu startet.
3. Prüfen Sie die Installation:
   ```bash theme={null}
   docker info --format '{{.Runtimes}}'                      # enthält runsc
   docker run --rm --runtime=runsc alpine:3 dmesg | head -3  # zeigt gVisor-Meldungen
   ```

## C. Sicherung

Legen Sie einen Snapshot der virtuellen Maschine an. Fahren Sie erst danach fort. Weitere Hinweise finden Sie unter [Backup und Wiederherstellung](https://docs.varios-ai.com/de/monthly/operations/backup.md).

## D. `.env` anpassen

1. Prüfen Sie die Tokens:
   ```bash theme={null}
   grep -E '^CODE_INTERPRETER_(API|WORKER)_TOKEN=' .env
   ```
2. Wird keine oder nur eine Zeile ausgegeben, legen Sie beide Tokens neu an. Der erste Befehl entfernt eine eventuell vorhandene einzelne Zeile:
   ```bash theme={null}
   sed -i '/^CODE_INTERPRETER_\(API\|WORKER\)_TOKEN=/d' .env
   echo "CODE_INTERPRETER_API_TOKEN=$(LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 64)"    >> .env
   echo "CODE_INTERPRETER_WORKER_TOKEN=$(LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 64)" >> .env
   ```
3. Wenn Sie gVisor installiert haben:
   ```bash theme={null}
   sed -i '/^DOCKER_RUNTIME=/d' .env
   echo "DOCKER_RUNTIME=runsc" >> .env
   ```
4. Ändern Sie `VERSION=` **nicht**.

## E. `docker-compose.yml` anpassen

Ergänzen Sie die bestehende `docker-compose.yml` von Hand, zum Beispiel mit Vim (`vi docker-compose.yml`) oder Nano (`nano docker-compose.yml`).

**1. Dienst `php` → `environment`:** nach `MARKITDOWN_URL` einfügen

```yaml theme={null}
      CODE_INTERPRETER_URL: "http://code-interpreter:8080"
      CODE_INTERPRETER_API_TOKEN: ${CODE_INTERPRETER_API_TOKEN}
      CODE_INTERPRETER_MAX_WORKSPACE_RAW_BYTES: ${CODE_INTERPRETER_MAX_WORKSPACE_RAW_BYTES:-12582912}
      CODE_INTERPRETER_MAX_WORKSPACE_FILES: ${CODE_INTERPRETER_MAX_WORKSPACE_FILES:-20}
      CODE_INTERPRETER_MAX_OUTPUT_FILE_BYTES: ${CODE_INTERPRETER_MAX_OUTPUT_FILE_BYTES:-10485760}
      CODE_INTERPRETER_ARCHIVE_MAX_DEPTH: ${CODE_INTERPRETER_ARCHIVE_MAX_DEPTH:-8}
```

**2. Dienst `php` → `depends_on`:** eine Zeile ergänzen

```yaml theme={null}
      - code-interpreter
```

**3. Drei neue Dienste** auf Ebene von `services:` einfügen, zum Beispiel vor `redis:`:

```yaml theme={null}
  code-interpreter:
    image: registry.varios-ai.com/variosai/code-interpreter-gateway:${VERSION}
    restart: always
    depends_on:
      - code-interpreter-worker
    init: true
    read_only: true
    cap_drop:
      - ALL
    security_opt:
      - no-new-privileges:true
    pids_limit: 256
    tmpfs:
      - /tmp:rw,nosuid,nodev,noexec,size=64m
    environment:
      PYTHONDONTWRITEBYTECODE: "1"
      PYTHONUNBUFFERED: "1"
      CODE_INTERPRETER_API_TOKEN: ${CODE_INTERPRETER_API_TOKEN}
      CODE_INTERPRETER_WORKER_URL: "http://code-interpreter-worker:8080"
      CODE_INTERPRETER_WORKER_TOKEN: ${CODE_INTERPRETER_WORKER_TOKEN}
      CODE_INTERPRETER_TIMEOUT_SECONDS: "60"
      CODE_INTERPRETER_MAX_REQUEST_BYTES: ${CODE_INTERPRETER_MAX_REQUEST_BYTES:-20000000}
      CODE_INTERPRETER_MAX_CODE_CHARS: ${CODE_INTERPRETER_MAX_CODE_CHARS:-200000}
      CODE_INTERPRETER_MAX_WORKSPACE_FILES: ${CODE_INTERPRETER_MAX_WORKSPACE_FILES:-20}
      CODE_INTERPRETER_MAX_WORKSPACE_FILE_B64_CHARS: ${CODE_INTERPRETER_MAX_WORKSPACE_FILE_B64_CHARS:-18000000}
    networks:
      - internal
      - code_interpreter_internal

  # Pull sandbox image and keep it on the host (idle holder) so docker system prune -a won't remove it.
  code-interpreter-sandbox-image:
    image: registry.varios-ai.com/variosai/code-interpreter-sandbox-python:${VERSION}
    command: ["sleep", "infinity"]
    restart: always

  code-interpreter-worker:
    image: registry.varios-ai.com/variosai/code-interpreter-worker:${VERSION}
    restart: always
    init: true
    read_only: true
    cap_drop:
      - ALL
    security_opt:
      - no-new-privileges:true
    pids_limit: 256
    tmpfs:
      - /tmp:rw,nosuid,nodev,noexec,size=64m
    environment:
      PYTHONDONTWRITEBYTECODE: "1"
      PYTHONUNBUFFERED: "1"
      CODE_INTERPRETER_WORKER_TOKEN: ${CODE_INTERPRETER_WORKER_TOKEN}
      VERSION: ${VERSION}
      CODE_INTERPRETER_TIMEOUT_SECONDS: "60"
      CODE_INTERPRETER_MEM_LIMIT: "512m"
      CODE_INTERPRETER_MAX_REQUEST_BYTES: ${CODE_INTERPRETER_MAX_REQUEST_BYTES:-20000000}
      CODE_INTERPRETER_MAX_CONCURRENT_EXECUTIONS: ${CODE_INTERPRETER_MAX_CONCURRENT_EXECUTIONS:-2}
      CODE_INTERPRETER_MAX_CODE_CHARS: ${CODE_INTERPRETER_MAX_CODE_CHARS:-200000}
      CODE_INTERPRETER_WORKDIR: ${CODE_INTERPRETER_WORKDIR:-/mnt}
      CODE_INTERPRETER_SANDBOX_UID: ${CODE_INTERPRETER_SANDBOX_UID:-65534}
      CODE_INTERPRETER_SANDBOX_GID: ${CODE_INTERPRETER_SANDBOX_GID:-65534}
      CODE_INTERPRETER_MAX_WORKSPACE_RAW_BYTES: ${CODE_INTERPRETER_MAX_WORKSPACE_RAW_BYTES:-12582912}
      CODE_INTERPRETER_MAX_WORKSPACE_FILES: ${CODE_INTERPRETER_MAX_WORKSPACE_FILES:-20}
      CODE_INTERPRETER_MAX_WORKSPACE_FILE_B64_CHARS: ${CODE_INTERPRETER_MAX_WORKSPACE_FILE_B64_CHARS:-18000000}
      CODE_INTERPRETER_WORKSPACE_TMPFS_MB: ${CODE_INTERPRETER_WORKSPACE_TMPFS_MB:-128}
      CODE_INTERPRETER_MAX_ARCHIVE_FILES: ${CODE_INTERPRETER_MAX_ARCHIVE_FILES:-30}
      CODE_INTERPRETER_MAX_OUTPUT_FILE_BYTES: ${CODE_INTERPRETER_MAX_OUTPUT_FILE_BYTES:-10485760}
      CODE_INTERPRETER_PIDS_LIMIT: ${CODE_INTERPRETER_PIDS_LIMIT:-128}
      CODE_INTERPRETER_NPROC_LIMIT: ${CODE_INTERPRETER_NPROC_LIMIT:-128}
      CODE_INTERPRETER_NOFILE_LIMIT: ${CODE_INTERPRETER_NOFILE_LIMIT:-1024}
      CODE_INTERPRETER_LOG_MAX_SIZE: ${CODE_INTERPRETER_LOG_MAX_SIZE:-64m}
      CODE_INTERPRETER_ARCHIVE_MAX_DEPTH: ${CODE_INTERPRETER_ARCHIVE_MAX_DEPTH:-8}
      # Sandbox runtime: unset/empty = default runc; set DOCKER_RUNTIME=runsc when gVisor is installed on the host.
      DOCKER_RUNTIME: ${DOCKER_RUNTIME:-}
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - code_interpreter_internal
```

**4. Abschnitt `networks:`** am Dateiende ergänzen

```yaml theme={null}
networks:
  internal:
  code_interpreter_internal:
    internal: true
```

**5. Imagenamen auf die neue Registry umstellen:** Der folgende Befehl ersetzt in der Datei die Domain `aibroker.azurecr.io` durch `registry.varios-ai.com`. Ältere Installationen verwenden zusätzlich noch den Pfad `avency/botapi/`; dieser wird zu `variosai/`.

```bash theme={null}
sed -i \
  -e 's#aibroker\.azurecr\.io/avency/botapi/#registry.varios-ai.com/variosai/#g' \
  -e 's#aibroker\.azurecr\.io/#registry.varios-ai.com/#g' \
  docker-compose.yml
grep -n 'image:' docker-compose.yml
```

In der Ausgabe darf `aibroker.azurecr.io` nicht mehr vorkommen. Der Code Interpreter startet seine Sandbox ausschließlich aus `registry.varios-ai.com/variosai/code-interpreter-sandbox-python`.

Prüfen Sie die Datei:

```bash theme={null}
docker compose config --quiet && echo OK
```

## F. Update ausführen

Wählen Sie eine der beiden Varianten. Wie der Update-Dienst arbeitet, beschreibt [systemd-Dienst](https://docs.varios-ai.com/de/monthly/security/systemd-service.md).

> [tab] Datei update\_version
>
> 1. ```bash theme={null}
>    systemctl is-active varios-update.service     # active
>    ```
> 2. ```bash theme={null}
>    echo "<ZIELVERSION>" > update_version
>    ```
> 3. Fortschritt verfolgen bis `Update successfully completed`:
>    ```bash theme={null}
>    journalctl -u varios-update.service -f
>    ```

> [tab] Manuell
>
> ```bash theme={null}
> sudo systemctl stop varios-update.service
> sed -i "s/^VERSION=.*/VERSION=<ZIELVERSION>/" .env
> echo "<ZIELVERSION>" > update_version
> docker compose pull
> docker compose up -d
> docker compose ps
> docker compose exec php ./update.sh
> docker system prune -f -a --volumes
> sudo systemctl start varios-update.service
> ```

## G. Nach dem Update: virtuelles Dateisystem befüllen

```bash theme={null}
cd /docker/variosai
docker compose exec -u www-data php /data/flow vfs:status
```

Die Ausgabe muss `No virtual filesystem containers exist yet.` lauten, **ohne** rote Fehlerzeile. Andernfalls beheben Sie zuerst den Fehler (Abschnitt I) und fahren dann fort.

```bash theme={null}
docker compose exec -u www-data php /data/flow vfs:backfill --dry-run
docker compose exec -u www-data php /data/flow vfs:backfill
docker compose exec -u www-data php /data/flow vfs:backfillknowledgebases --dry-run
docker compose exec -u www-data php /data/flow vfs:backfillknowledgebases
docker compose exec -u www-data php /data/flow vfs:status
```

## H. Prüfen

1. ```bash theme={null}
   docker compose ps                                   # alle running, keine Restart-Schleife
   docker compose images | grep -E 'php|code-interpreter'   # alle <ZIELVERSION>
   docker compose logs --tail=30 code-interpreter code-interpreter-worker
   docker compose exec php curl -s http://code-interpreter:8080/health     # {"status":"ok"}
   ```
2. In der Oberfläche zeigt **System Informationen** `<ZIELVERSION>`, und **Dienstzustände** enthält keine roten Einträge.
3. Wenn Sie gVisor installiert haben: Ein Sandbox-Lauf dauert nur wenige Sekunden. Starten Sie deshalb vor dem Testchat den folgenden Befehl. Er wartet auf den nächsten Sandbox-Container und gibt dessen Runtime aus:
   ```bash theme={null}
   image=registry.varios-ai.com/variosai/code-interpreter-sandbox-python:<ZIELVERSION>
   until ids=$(docker ps -q --filter network=none --filter ancestor="$image") && [ -n "$ids" ] \
     && docker inspect --format '{{.Name}} runtime={{.HostConfig.Runtime}}' $ids 2>/dev/null; do
     sleep 0.2
   done
   ```
4. Starten Sie einen Testchat mit Code Interpreter: „Berechne mit Python die ersten 20 Primzahlen und speichere sie als primzahlen.txt.“ Die Datei erscheint im Chat und im Panel **Dateien**. Bei gVisor gibt der Befehl aus Schritt 3 jetzt `runtime=runsc` aus und endet. Schlägt der Testchat fehl, beenden Sie den Befehl mit `Strg+C`.
5. Stellen Sie einem Assistenten mit Dateien eine Frage, deren Antwort aus seinen Dateien stammen muss.
6. ```bash theme={null}
   systemctl is-active varios-update.service     # active
   tail -n 20 Data/Logs/System.log               # keine AVX2-Warnung
   ```

## I. Wenn etwas fehlschlägt

| Meldung / Symptom | Maßnahme |
| - | - |
| Gateway-Log: `CODE_INTERPRETER_API_TOKEN must be set` / `must be at least 32 bytes` / `must not be identical` | Abschnitt D wiederholen, dann `docker compose up -d code-interpreter code-interpreter-worker` |
| `vfs:status`: `CODE_INTERPRETER_URL is not configured` | Abschnitt E prüfen, dann `docker compose up -d php` |
| `vfs:status`: `No embedding model is configured` / `has no credential` | Ein [Embedding-Modell](https://docs.varios-ai.com/de/monthly/admin/models/embedding.md) mit Zugangsdaten anlegen |
| `docker compose pull` meldet `unauthorized` oder `denied` für `registry.varios-ai.com` | Abschnitt A, Schritt 3 mit `sudo -H` wiederholen; wenn Sie `docker` ohne `sudo` aufrufen, zusätzlich ohne `sudo -H` |
| Worker-Log: `Interpreter image not available locally` | Prüfen, ob `code-interpreter-sandbox-image` auf `registry.varios-ai.com/variosai/code-interpreter-sandbox-python` zeigt (Abschnitt E, Schritt 5), dann `docker compose pull code-interpreter-sandbox-image && docker compose up -d code-interpreter-sandbox-image` |
| Worker-Log: `unknown or invalid runtime name: runsc` | Abschnitt B (Registrierung laut gVisor-Dokumentation, Docker-Neustart), dann `docker compose restart code-interpreter-worker` |
| Abschnitt H, Schritt 3 zeigt `runtime=runc` | `DOCKER_RUNTIME=runsc` in `.env` (Abschnitt D) und `DOCKER_RUNTIME: ${DOCKER_RUNTIME:-}` am Dienst `code-interpreter-worker` (Abschnitt E) prüfen, dann `docker compose up -d code-interpreter-worker` |
| `vfs:backfill`: `A backfill is already running` | Warten; andernfalls die Lock-Datei `Data/Data/Persistent/vfs_backfill.lock` prüfen |
| `update.sh` bricht ab | Meldung lesen, Ursache beheben, `docker compose exec php ./update.sh` erneut ausführen |
| `.env` zeigt wieder die alte `VERSION` | `VERSION` wurde bei laufendem Update-Dienst von Hand geändert → Abschnitt F, Variante **Datei update\_version** oder **Manuell** |

> [!WARNING]
>
> **Rollback:** Spielen Sie den VM-Snapshot zurück. Führen Sie kein Downgrade über **Version ändern** aus.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.