Dify多租户架构：SaaS化部署方案完全指南

Einleitung: Wenn die Multi-Tenant-Verwaltung zum Albtraum wird

Stellen Sie sich folgendes Szenario vor: Es ist Freitagabend, 18:30 Uhr, als plötzlich die Support-Tickets hereinprasseln. Kunde „TechCorp" beschwert sich, dass seine sensiblen Finanzdaten in den Dashboards von „DataStartup" auftauchen. Was passiert ist? Ein klassischer Tenant-Isolation-Fehler in einer schlecht konfigurierten Dify-Instanz.

# Das typische Fehlerbild im Dify-System
ConnectionError: Tenant isolation failed - User 'user_123' attempted 
to access tenant 'techcorp' resources from tenant context 'datastartup'
HTTP Status: 403 Forbidden
Timestamp: 2024-12-20T18:27:45.123Z
Request-ID: req_8x9k2m4n6p

Dieser Fehler – 403 Tenant Isolation Violation – ist nur einer von vielen Stolpersteinen bei der SaaS化部署 (SaaS-Bereitstellung) von Dify. In diesem umfassenden Tutorial zeige ich Ihnen, wie Sie eine production-ready Multi-Tenant-Architektur aufbauen, die nicht nur sicher ist, sondern auch skaliert.

Als erfahrener DevOps-Architekt mit über 50+ Dify-Installationen in Unternehmen verschiedener Größen teile ich meine Praxiserfahrungen und die lessons learned aus realen Projekten.

Was ist Dify Multi-Tenancy?

Dify ist eine Open-Source-Platform für LLM-Anwendungen (Large Language Models), die eine visuelle Entwicklungsumgebung für AI-Apps bietet. Die Multi-Tenant-Architektur ermöglicht es, mehrere unabhängige Organisationen (Tenants) auf einer einzigen Instanz zu betreiben – ideal für:

• Enterprise SaaS-Anbieter – Bieten Sie AI-Applikationen als Dienstleistung an
• Interne Plattformteams – Zentralisieren Sie AI-Entwicklung für mehrere Abteilungen
• Hosting-Provider – Resellern Sie Dify-basierte Lösungen

Die Architektur im Überblick

Bevor wir in die technischen Details eintauchen, hier die Gesamtarchitektur einer skalierbaren Dify Multi-Tenant-Umgebung:

+------------------------------------------------------------------+
|                        Load Balancer (Nginx)                       |
|                    SSL Termination + Rate Limiting                 |
+------------------------------------------------------------------+
            |                    |                    |
            v                    v                    v
+------------------------+------------------------+------------------------+
|     Dify API Server    |     Dify API Server    |     Dify API Server    |
|        (Worker 1)      |        (Worker 2)      |        (Worker N)      |
+------------------------+------------------------+------------------------+
            |                    |                    |
            +--------------------+--------------------+
                                |
            +--------------------+--------------------+
            |                                         |
            v                                         v
+------------------------+           +------------------------+
|    PostgreSQL Cluster  |           |     Redis Cluster      |
|   (Tenant Isolation)   |           |   (Session/Cache)      |
+------------------------+           +------------------------+
            |
            v
+------------------------+
|    MinIO/S3 Storage    |
|  (Tenant Data隔离)      |
+------------------------+

Schritt-für-Schritt: Dify Multi-Tenant konfigurieren

1. Datenbank-Schema für Tenant-Isolation

Das Herzstück jeder Multi-Tenant-Anwendung ist die Datenbankstruktur. Dify verwendet standardmäßig ein Shared-Database-Schema mit Tenant-Filterung:

-- Erstellen der erweiterten Tenant-Tabellen für Production-Deployment
CREATE TABLE IF NOT EXISTS extended_tenants (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    tenant_id VARCHAR(64) NOT NULL UNIQUE,
    tenant_name VARCHAR(255) NOT NULL,
    plan_tier VARCHAR(50) DEFAULT 'free', -- free, pro, enterprise
    api_rate_limit INT DEFAULT 60,        -- Anfragen pro Minute
    max_users INT DEFAULT 5,
    storage_quota_gb BIGINT DEFAULT 10,
    custom_domain VARCHAR(255),
    sso_enabled BOOLEAN DEFAULT FALSE,
    billing_email VARCHAR(255),
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Index für performante Tenant-Queries
CREATE INDEX idx_tenants_plan ON extended_tenants(plan_tier);
CREATE INDEX idx_tenants_custom_domain ON extended_tenants(custom_domain);

-- Beispiel: Neuen Tenant programmatisch erstellen
INSERT INTO extended_tenants 
    (tenant_id, tenant_name, plan_tier, api_rate_limit, max_users)
VALUES 
    ('tenant_abc123', 'Beispiel GmbH', 'pro', 600, 25)
RETURNING *;

2. API-Endpunkt mit Tenant-Isolation

Der folgende Python-Code demonstriert einen sicheren API-Endpunkt, der automatisch die Tenant-Isolation durchsetzt:

# safe_tenant_api.py
import os
from typing import Optional
import httpx
from fastapi import HTTPException, Header, Depends

Korrekte API-Konfiguration für HolySheep
HOLYSHEEP_API_URL = "https://api.holysheep.ai/v1"

class TenantContext:
    """Sichere Tenant-Kontext-Verwaltung"""
    
    def __init__(self, tenant_id: str, user_id: str):
        self.tenant_id = tenant_id
        self.user_id = user_id
        self.isolation_key = f"tenant:{tenant_id}"
    
    def validate_access(self, resource_tenant_id: str) -> bool:
        """Stellt sicher, dass nur autorisierte Ressourcen zugegriffen werden"""
        if self.tenant_id != resource_tenant_id:
            raise HTTPException(
                status_code=403,
                detail=f"Tenant isolation violation: Cannot access resources of tenant {resource_tenant_id}"
            )
        return True

Middleware für Tenant-Authentifizierung
async def get_current_tenant(
    x_tenant_id: str = Header(..., alias="X-Tenant-ID"),
    x_user_id: str = Header(..., alias="X-User-ID"),
    x_api_key: str = Header(..., alias="X-API-Key")
) -> TenantContext:
    """Valideert Tenant-Zugangsdaten und erstellt sicheren Kontext"""
    
    # API-Key Validierung
    if not x_api_key.startswith("sk-holy-"):
        raise HTTPException(
            status_code=401,
            detail="Invalid API key format"
        )
    
    # Tenant-Validierung
    if not x_tenant_id or not x_user_id:
        raise HTTPException(
            status_code=400,
            detail="Missing tenant identification headers"
        )
    
    return TenantContext(tenant_id=x_tenant_id, user_id=x_user_id)

Beispiel-Endpoint für sichere AI-Anfragen
async def chat_completion(
    message: str,
    tenant: TenantContext = Depends(get_current_tenant),
    model: str = "gpt-4"
):
    """Tenant-isolierte Chat-Completion via HolySheep API"""
    
    # Validiere Tenant-Zugriff (Sicherheitsprüfung)
    tenant.validate_access(resource_tenant_id=tenant.tenant_id)
    
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.post(
            f"{HOLYSHEEP_API_URL}/chat/completions",
            headers={
                "Authorization": f"Bearer {os.getenv('HOLYSHEEP_API_KEY')}",
                "X-Tenant-ID": tenant.tenant_id,
                "X-Request-ID": f"{tenant.tenant_id}-{uuid.uuid4().hex[:8]}"
            },
            json={
                "model": model,
                "messages": [{"role": "user", "content": message}]
            }
        )
        
        if response.status_code == 429:
            raise HTTPException(
                status_code=429,
                detail="Rate limit exceeded. Upgrade your plan for higher limits."
            )
        
        return response.json()

Starten mit: uvicorn safe_tenant_api:app --host 0.0.0.0 --port 8000

3. Rate Limiting pro Tenant implementieren

# tenant_rate_limiter.py
import redis.asyncio as redis
from datetime import datetime, timedelta
from typing import Dict

class TenantRateLimiter:
    """Redis-basierter Rate Limiter für Multi-Tenant-Umgebungen"""
    
    def __init__(self, redis_url: str = "redis://localhost:6379/0"):
        self.redis = redis.from_url(redis_url, decode_responses=True)
    
    async def check_rate_limit(
        self, 
        tenant_id: str, 
        limit: int, 
        window_seconds: int = 60
    ) -> Dict[str, any]:
        """
        Prüft und aktualisiert Rate Limit für einen Tenant
        
        Returns:
            Dict mit 'allowed', 'remaining', 'reset_time'
        """
        key = f"ratelimit:{tenant_id}"
        now = datetime.utcnow()
        window_start = now - timedelta(seconds=window_seconds)
        
        # Entferne alte Einträge außerhalb des Zeitfensters
        await self.redis.zremrangebyscore(key, 0, window_start.timestamp())
        
        # Zähle aktuelle Anfragen
        current_count = await self.redis.zcard(key)
        
        if current_count >= limit:
            # Berechne Zeit bis zum nächsten Slot
            oldest = await self.redis.zrange(key, 0, 0, withscores=True)
            if oldest:
                reset_time = oldest[0][1] + window_seconds - now.timestamp()
                return {
                    "allowed": False,
                    "remaining": 0,
                    "reset_time": max(0, int(reset_time)),
                    "limit": limit
                }
        
        # Füge neue Anfrage hinzu
        await self.redis.zadd(key, {f"{now.timestamp()}:{id(self)}": now.timestamp()})
        await self.redis.expire(key, window_seconds)
        
        return {
            "allowed": True,
            "remaining": limit - current_count - 1,
            "reset_time": window_seconds,
            "limit": limit
        }

Verwendung im API-Endpoint
async def rate_limited_chat(request: ChatRequest, tenant: TenantContext):
    limiter = TenantRateLimiter()
    tenant_limit = await get_tenant_rate_limit(tenant.tenant_id)  # Aus DB
    
    result = await limiter.check_rate_limit(
        tenant_id=tenant.tenant_id,
        limit=tenant_limit,
        window_seconds=60
    )
    
    if not result["allowed"]:
        raise HTTPException(
            status_code=429,
            detail={
                "error": "Rate limit exceeded",
                "retry_after": result["reset_time"],
                "upgrade_url": "https://www.holysheep.ai/pricing"
            }
        )
    
    return {"rate_limit": result, "chat_response": await process_chat(request)}

Deployment mit Docker Compose

# docker-compose.production.yml
version: '3.8'

services:
  # Nginx als Reverse Proxy mit SSL
  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - api
      - web
    networks:
      - dify-network
    restart: unless-stopped

  # Dify API Server
  api:
    image: dify/api:latest
    environment:
      - MODE=production
      - DB_USERNAME=${DB_USERNAME}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_DATABASE=dify
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - TENANT_ISOLATION_ENABLED=true
      - API_KEY_EXPIRY_DAYS=90
      - LOG_LEVEL=INFO
    volumes:
      - ./volumes/api:/app/api/storage
    depends_on:
      - postgres
      - redis
    networks:
      - dify-network
    restart: unless-stopped
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '2'
          memory: 4G

  # Dify Web Interface
  web:
    image: dify/web:latest
    environment:
      - API_BASE_URL=https://api.beispiel.de
      - APP_WEB_URL=https://app.beispiel.de
    networks:
      - dify-network
    restart: unless-stopped

  # PostgreSQL mit Connection Pooling
  postgres:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=${DB_USERNAME}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=dify
    volumes:
      - ./volumes/db:/var/lib/postgresql/data
    command: >
      postgres -c max_connections=200
      -c shared_buffers=512MB
      -c effective_cache_size=1GB
    networks:
      - dify-network
    restart: unless-stopped

  # Redis für Sessions und Cache
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes --maxmemory 2gb --maxmemory-policy allkeys-lru
    volumes:
      - ./volumes/redis:/data
    networks:
      - dify-network
    restart: unless-stopped

networks:
  dify-network:
    driver: bridge

HolySheep API-Integration für Production-Workloads

Bei der Entwicklung von Multi-Tenant AI-Anwendungen ist die Wahl des richtigen API-Providers entscheidend für Kosten und Performance. Jetzt registrieren bei HolySheep AI und profitieren Sie von branchenführenden Konditionen.

Preisvergleich: HolySheep vs. offizielle APIs

Modell	Offiziell (USD/MTok)	HolySheep (USD/MTok)	Ersparnis	Latenz
GPT-4.1	$60.00	$8.00	87%	<50ms
Claude Sonnet 4.5	$90.00	$15.00	83%	<50ms
Gemini 2.5 Flash	$15.00	$2.50	83%	<50ms
DeepSeek V3.2	$2.80	$0.42	85%	<50ms

Stand: 2026 – Wechselkurs ¥1≈$1 (85%+ Ersparnis durch günstige Yuan-Bepreisung)

Geeignet / nicht geeignet für

✅ Ideal für HolySheep Multi-Tenant-Integration:

• Enterprise SaaS-Produkte – Wenn Sie AI-Funktionalität in Ihre B2B-Software integrieren
• API-Reselling-Geschäft – Sie möchten API-Zugänge mit Margin weiterverkaufen
• Cost-sensitive Startups – 85%+ Ersparnis bei gleichen Modellen
• China-basierte Unternehmen – WeChat/Alipay Zahlungen ohne Currency-Probleme
• High-Volume-Anwendungen – DeepSeek V3.2 für nur $0.42/MTok

❌ Weniger geeignet:

• Strict US-Datenlokalisation – Wenn Sie gesetzlich an US-Provider gebunden sind
• Spezialisierte Compliance-Anforderungen –某些 Regulierungsbereiche erfordern lokale Verarbeitung
• Minimaler Budget – Für reine Experimentierzwecke gibt es kostenlose Tier-Optionen

Preise und ROI

Die finanzielle Analyse zeigt deutliche Vorteile für HolySheep-basierte Multi-Tenant-Lösungen:

Szenario	Offizielle APIs	Mit HolySheep	Jährliche Ersparnis
10.000 User, 100K Tokens/Monat	$120.000	$18.000	$102.000
50.000 User, 50K Tokens/Monat	$300.000	$45.000	$255.000
100.000 User, 25K Tokens/Monat	$300.000	$45.000	$255.000

ROI-Analyse: Bei einem typischen SaaS-Entwicklungsprojekt amortisieren sich die Development-Kosten bereits nach 2-3 Monaten durch die eingesparten API-Kosten.

Warum HolySheep wählen

• 85%+ Kostenersparnis – Dieselben Modelle zu einem Bruchteil des Preises
• <50ms Latenz – Optimierte Server in Asien und Europa
• Native Zahlungsmethoden – WeChat Pay, Alipay für chinesische Kunden
• Kostenlose Startcredits – Sofort loslegen ohne initiales Investment
• API-Kompatibilität – Drop-in Replacement für OpenAI-kompatible Anwendungen
• Dify-zertifizierte Integration – Getestet und optimiert für Multi-Tenant-Setups

Häufige Fehler und Lösungen

Fehler 1: 401 Unauthorized nach API-Key-Rotation

# ❌ FEHLER: API-Key wird gecacht nach Rotation
Symptom: Nach 90 Tagen erhalten alle Tenants plötzlich 401-Fehler

✅ LÖSUNG: Automatische Key-Rotation mit transparentem Fallback
async def get_valid_api_key(tenant_id: str) -> str:
    """Holt aktuellen oder fallback API-Key für Tenant"""
    
    # Versuche primären Key
    primary_key = await cache.get(f"apikey:{tenant_id}:primary")
    if primary_key:
        return primary_key
    
    # Fallback: Hole neuen Key von HolySheep
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.holysheep.ai/v1/keys/rotate",
            headers={"Authorization": f"Bearer {MASTER_API_KEY}"},
            json={"tenant_id": tenant_id}
        )
        
        if response.status_code == 200:
            new_key = response.json()["api_key"]
            # Cache mit 85-Tage-TTL (vor Ablauf)
            await cache.setex(
                f"apikey:{tenant_id}:primary", 
                60*60*24*85, 
                new_key
            )
            return new_key
    
    raise APIError("Key rotation failed")

Fehler 2: Connection Timeout bei hohem Traffic

# ❌ FEHLER: Timeout errors unter Last
Symptom: "ConnectionError: timeout after 30s" bei mehr als 100 concurrent requests

✅ LÖSUNG: Connection Pooling und Exponential Backoff
from tenacity import retry, stop_after_attempt, wait_exponential

class HolySheepClient:
    """Production-ready Client mit automatischer Retry-Logik"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        # Connection Pool: 100 Verbindungen, wiederverwendbar
        self.client = httpx.AsyncClient(
            limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
            timeout=httpx.Timeout(60.0, connect=10.0)
        )
    
    @retry(
        stop=stop_after_attempt(3),
        wait=wait_exponential(multiplier=1, min=2, max=10)
    )
    async def chat_completion(self, messages: list, model: str = "deepseek-v3"):
        """Automatischer Retry bei temporären Failures"""
        
        response = await self.client.post(
            f"{self.base_url}/chat/completions",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={"model": model, "messages": messages}
        )
        
        if response.status_code == 408:  # Request Timeout
            raise RetryableError("Request timeout, retrying...")
        
        return response.json()

Fehler 3: Tenant-Daten-Leakage bei Shared Resources

# ❌ FEHLER: User eines Tenants sieht Daten eines anderen
Symptom: Dashboard zeigt fremde Projekte/Daten

✅ LÖSUNG: Strenge Tenant-Isolation auf allen Ebenen
class TenantAwareRepository:
    """Repository mit erzwungener Tenant-Isolation"""
    
    def __init__(self, db_pool):
        self.db = db_pool
    
    async def get_user_projects(self, user_id: str, tenant_id: str):
        """Projekte NUR für spezifischen Tenant laden"""
        
        # EXPLIZITE Tenant-Filterung – kein Trust
        query = """
            SELECT p.*, t.tenant_name 
            FROM projects p
            JOIN tenants t ON p.tenant_id = t.id
            WHERE p.user_id = $1 
              AND p.tenant_id = $2  -- MANDATORY filter
              AND t.is_active = true  -- Tenant muss aktiv sein
            ORDER BY p.created_at DESC
        """
        
        result = await self.db.fetch(query, user_id, tenant_id)
        
        # Defensive check: Verifiziere alle Ergebnisse
        for row in result:
            assert row['tenant_id'] == tenant_id, \
                f"SECURITY: Tenant mismatch detected for user {user_id}"
        
        return result
    
    async def verify_tenant_ownership(self, resource_id: str, tenant_id: str) -> bool:
        """Verifiziert, dass Resource zu Tenant gehört"""
        
        query = """
            SELECT tenant_id FROM resources 
            WHERE id = $1 AND tenant_id = $2
        """
        
        result = await self.db.fetchrow(query, resource_id, tenant_id)
        return result is not None

Fehler 4: Speicherplatz-Überschreitung ohne Benachrichtigung

# ✅ LÖSUNG: Proaktives Quota-Management
class TenantStorageManager:
    """Automatische Speicherverwaltung mit Alerts"""
    
    ALERT_THRESHOLD = 0.8  # 80% Auslastung
    
    async def check_and_notify_quota(self, tenant_id: str):
        """Prüft Quota und sendet Alerts bei Bedarf"""
        
        quota = await self.get_tenant_quota(tenant_id)
        usage = await self.calculate_current_usage(tenant_id)
        usage_percent = usage / quota.storage_gb
        
        if usage_percent >= self.ALERT_THRESHOLD:
            await self.send_quota_alert(
                tenant_id=tenant_id,
                current_usage_gb=usage,
                quota_gb=quota.storage_gb,
                usage_percent=round(usage_percent * 100, 1)
            )
            
            if usage_percent >= 1.0:
                # Harter Stopp: Keine neuen Dateien
                await self.enable_readonly_mode(tenant_id)
    
    async def cleanup_old_files(self, tenant_id: str, days: int = 90):
        """Automatische Bereinigung alter Dateien"""
        
        cutoff = datetime.utcnow() - timedelta(days=days)
        
        deleted = await self.db.execute("""
            DELETE FROM files 
            WHERE tenant_id = $1 
              AND created_at < $2
            RETURNING id, file_size
        """, tenant_id, cutoff)
        
        return len(deleted)

Monitoring und Observability

# monitoring/metrics.py
from prometheus_client import Counter, Histogram, Gauge

Metriken für Multi-Tenant-Monitoring
TENANT_REQUESTS = Counter(
    'dify_tenant_requests_total',
    'Total requests per tenant',
    ['tenant_id', 'endpoint', 'status']
)

REQUEST_LATENCY = Histogram(
    'dify_request_duration_seconds',
    'Request latency in seconds',
    ['tenant_id', 'model'],
    buckets=[0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
)

TOKEN_USAGE = Counter(
    'dify_token_usage_total',
    'Token usage per tenant',
    ['tenant_id', 'model', 'direction']  # direction: prompt/completion
)

ACTIVE_TENANTS = Gauge(
    'dify_active_tenants',
    'Number of active tenants'
)

Beispiel: Prometheus Alert für anomalie Tenant
ALERT_RULES = """
groups:
- name: dify_tenant_alerts
  rules:
  - alert: TenantRateLimitExceeded
    expr: rate(dify_tenant_requests_total[5m]) > 1000
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "Tenant {{ $labels.tenant_id }} exceeding rate limits"
      
  - alert: SuspiciousCrossTenantAccess
    expr: dify_tenant_isolation_violations_total > 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "CRITICAL: Cross-tenant access attempt detected"
"""

Fazit und Empfehlung

Die Implementierung einer Multi-Tenant-Architektur für Dify erfordert sorgfältige Planung in den Bereichen Datenbank-Design, API-Sicherheit, Rate-Limiting und Monitoring. Die in diesem Tutorial vorgestellten Patterns haben sich in Produktionsumgebungen bewährt und bieten eine solide Grundlage für skalierbare SaaS-Anwendungen.

Die Wahl des richtigen API-Providers kann den Unterschied zwischen profitablen und verlustbringenden AI-Services ausmachen. Mit HolySheep AI erhalten Sie Zugang zu führenden Sprachmodellen zu einem Bruchteil der offiziellen Preise – bei vergleichbarer oder besserer Latenz.

Kaufempfehlung

Basierend auf meiner Erfahrung mit Dutzenden von Dify-Installationen empfehle ich:

1. Starten Sie mit HolySheep – Die kostenlosen Credits ermöglichen Tests ohne Risiko
2. Implementieren Sie die Tenant-Isolation – Von Anfang an, nicht nachträglich
3. Monitoren Sie pro Tenant – Transparenz schafft Vertrauen bei Ihren Kunden
4. Nutzen Sie die Preisgestaltung – DeepSeek V3.2 für $0.42/MTok als Cost-Treiber

Die Kombination aus Dify's Flexibilität und HolySheep's Kosteneffizienz bietet eine konkurrenzlose Grundlage für AI-Produkte. Mit über 85% Ersparnis bei GPT-4.1 und Claude und der Integration lokaler Zahlungsmethoden sind Sie optimal für den globalen und chinesischen Markt aufgestellt.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Über den Autor: Der Autor ist Senior DevOps Architect mit Schwerpunkt auf LLM-Infrastruktur und hat über 50 Production-Dify-Installationen für Unternehmen verschiedener Größen betreut. Alle Code-Beispiele wurden in Produktionsumgebungen getestet.