Docker-Beispiel

Diese Seite zeigt ein reproduzierbares Docker-Setup, um ein AugeLab Studio .pmod-Szenario headless auszuführen.

Das Image wird lokal aus einem Dockerfile gebaut. Kund:innen benötigen nicht den AugeLab-Quellcode. Der Container installiert das Closed-Source-Paket studio aus dem AugeLab-Paketindex während des Image-Builds.

Voraussetzungen

• Docker Desktop oder Docker Engine mit Docker Compose.

• Zugriff auf den AugeLab-Paketindex.

• Ein AugeLab-Verifizierungscode.

• Eine .pmod-Szenario-Datei, die headless laufen kann.

• Für GPU/CUDA: NVIDIA Container Toolkit auf dem Host installiert.

Schnellstart

1. Erstelle die untenstehende Ordnerstruktur.

2. Lege deine .pmod-Datei in app/.

3. Füge deinen Verifizierungscode in .env ein.

4. Verwende das CPU- oder das GPU-Dockerfile.

5. Führe docker compose up --build aus.

6. Prüfe output_on_host.

Projektstruktur

augelab-docker-example/
  .env
  docker-compose.yml
  docker-compose.cuda.yml
  output_on_host/
  app/
    Dockerfile
    Dockerfile.cuda
    run_scenario.py
    your_scenario.pmod

Ersetze your_scenario.pmod durch deine eigene Szenario-Datei.

.env-Datei

Erstelle .env neben docker-compose.yml:

.env

AUGELAB_VERIFICATION_CODE=PASTE_YOUR_VERIFICATION_CODE_HERE
SCENARIO_PATH=your_scenario.pmod

Wenn .env einen echten Verifizierungscode enthält, nicht ins Versionskontrollsystem committen.

Szenario-Ausführungsskript

Erstelle app/run_scenario.py:

app/run_scenario.py

import os
from pathlib import Path

from studio import StudioScenario


OUTPUT_DIR = Path("/app/app_output")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

verification_code = os.environ.get("AUGELAB_VERIFICATION_CODE")
if not verification_code:
    raise RuntimeError("AUGELAB_VERIFICATION_CODE is not set.")

scenario_path = os.environ.get("SCENARIO_PATH", "your_scenario.pmod")
if not Path(scenario_path).is_file():
    raise FileNotFoundError(f"Scenario file not found: {scenario_path}")

scenario = StudioScenario(verification_code=verification_code)
scenario.enable_logging_stdout()
scenario.load_scenario(scenario_path)

try:
    print("Scenario result:", scenario.run())
finally:
    scenario.cleanup()

Wenn dein Szenario Dateien schreibt, konfiguriere es so, dass sie unter /app/app_output abgelegt werden.

CPU-Dockerfile

Dieses Dockerfile ist für reguläre headless CPU-Läufe:

app/Dockerfile

FROM python:3.12-slim-bookworm

WORKDIR /app

RUN apt-get update -y && \
    apt-get install -y --no-install-recommends \
    libdmtx0b \
    zbar-tools \
    build-essential \
    libgl1-mesa-glx \
    curl \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

ADD https://astral.sh/uv/0.9.17/install.sh /uv-installer.sh
RUN sh /uv-installer.sh && rm /uv-installer.sh

ENV PATH="/root/.local/bin/:$PATH"

RUN uv pip install studio --system \
    --extra-index-url https://pyrepo.augelab.com \
    --extra-index-url https://download.pytorch.org/whl/cpu \
    --index-strategy unsafe-best-match

RUN python -c "from studio import StudioScenario; print('studio import ok')"

COPY run_scenario.py .
COPY your_scenario.pmod .

CMD ["python", "run_scenario.py"]

GPU/CUDA-Dockerfile

Verwende dieses Dockerfile, wenn dein Szenario CUDA-Beschleunigung benötigt. Der Host muss kompatible NVIDIA-Treiber und das NVIDIA Container Toolkit haben.

app/Dockerfile.cuda

FROM nvidia/cuda:12.8.0-cudnn-runtime-ubuntu22.04

WORKDIR /app

RUN apt-get update -y && \
    apt-get install -y --no-install-recommends \
    python3 \
    python3-venv \
    python3-pip \
    libdmtx0b \
    zbar-tools \
    build-essential \
    libgl1-mesa-glx \
    curl \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

ADD https://astral.sh/uv/0.9.17/install.sh /uv-installer.sh
RUN sh /uv-installer.sh && rm /uv-installer.sh

ENV PATH="/root/.local/bin/:$PATH"
ENV NVIDIA_VISIBLE_DEVICES=all
ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility

RUN uv pip install "studio[gpu]" --system \
    --extra-index-url https://pyrepo.augelab.com \
    --index-strategy unsafe-best-match

RUN python3 -c "from studio import StudioScenario; print('studio gpu import ok')"

COPY run_scenario.py .
COPY your_scenario.pmod .

CMD ["python3", "run_scenario.py"]

Compose-Datei

Verwende diese Datei für das CPU-Dockerfile:

docker-compose.yml

services:
  augelab-headless:
    build:
      context: ./app
      dockerfile: Dockerfile
    env_file:
      - .env
    volumes:
      - ./output_on_host:/app/app_output

Dies mountet ./output_on_host aus deinem Projektordner in den Container nach /app/app_output.

Unter Windows: Verwende Vorwärtsschrägstriche in absoluten Docker-Mount-Pfaden, z. B. C:/work/augelab_output:/app/app_output. Relative Mounts wie ./output_on_host:/app/app_output sind in der Regel leichter zwischen Maschinen zu teilen.

GPU/CUDA Compose-Datei

Verwende diese Datei für Dockerfile.cuda:

docker-compose.cuda.yml

services:
  augelab-headless-gpu:
    build:
      context: ./app
      dockerfile: Dockerfile.cuda
    env_file:
      - .env
    volumes:
      - ./output_on_host:/app/app_output
    gpus: all

Image erstellen und starten

CPU:

docker compose up --build

GPU/CUDA:

docker compose -f docker-compose.cuda.yml up --build

Du solltest die AugeLab Studio-Logs und das Szenarioergebnis im Terminal sehen.

Ausgabe überprüfen

Prüfe output_on_host auf deinem Hostsystem. Dateien, die das Szenario nach /app/app_output schreibt, sollten dort erscheinen.

Fehlerbehebung

Problem	Prüfe
studio-Installation schlägt fehl	Bestätige Netzwerkzugang und Zugriff auf den AugeLab-Paketindex.
Lizenz/Aktivierung schlägt fehl	Prüfe, ob AUGELAB_VERIFICATION_CODE gesetzt ist und der Container Internetzugang hat.
Szenario-Datei nicht gefunden	Prüfe, ob SCENARIO_PATH mit der durch das Dockerfile kopierten .pmod übereinstimmt.
Ausgabeordner ist leer	Prüfe, ob die .pmod nach /app/app_output schreibt.
Windows-Volume wird nicht gemountet	Verwende Vorwärtsschrägstriche und bestätige, dass Docker Desktop auf das Laufwerk zugreifen darf.
GPU-Container sieht GPU nicht	Installiere das NVIDIA Container Toolkit und teste mit docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu22.04 nvidia-smi.