KI-Agenten im Dauerbetrieb

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Dauerbetrieb behandelt

• Wie Du KI-Agenten 24/7 betreibst.
• Monitoring, Wartung und Fehlerbehandlung für Dauerbetrieb.
• Wie Du Agenten zuverlässig und stabil hältst.
• Praxisbeispiele für Continuous-Operation-Agenten.
• Best Practices für Verfügbarkeit, Performance und Wartung.

Einleitung: Dauerbetrieb verständlich erklärt

Dauerbetrieb bedeutet: Dein Agent läuft 24/7, verarbeitet kontinuierlich Aufgaben, überwacht sich selbst und erholt sich bei Fehlern. Nicht nur „Agent starten”, sondern „Agent läuft dauerhaft zuverlässig”.

Dieser Artikel richtet sich an Anwender, die Agenten im Dauerbetrieb betreiben wollen. Grundlagen findest Du in KI-Agenten lokal betreiben und Monitoring.

Warum brauche ich Dauerbetrieb?

Stell Dir vor, Dein Agent soll E-Mails rund um die Uhr verarbeiten. Nicht nur wenn Du ihn startest, sondern dauerhaft: Nachts, am Wochenende, bei Fehlern automatisch neu starten. Dauerbetrieb bedeutet zuverlässige, kontinuierliche Verfügbarkeit.

Dauerbetrieb kurz erklärt

Agent läuft 24/7 → Monitoring überwacht → Bei Fehler: Auto-Restart → Bei Erfolg: Weiterarbeit. Mit Logging, Alerting und Self-Healing für Zuverlässigkeit.

Der Kerngedanke lautet: Kontinuierliche Verfügbarkeit ohne manuelle Intervention.

Für wen ist dieser Artikel gedacht?

• Produktions-Teams, die Agenten dauerhaft betreiben.
• DevOps, die Verfügbarkeit sicherstellen.
• Unternehmen, die 24/7-Automatisierung wollen.
• Self-Hoster, die zuverlässige Agenten betreiben.

Wichtige Begriffe

• Monitoring - Überwachung. Wann nützlich: für Dauerbetrieb.
• Protokollierung - Logging. Wann nützlich: für Debugging.
• Ollama - Modellserver. Wann nützlich: für Dauerbetrieb.
• Docker - Für Deployment. Wann nützlich: für Auto-Restart.
• Systemd - Service-Management. Wann nützlich: für Auto-Start.

Architektur für Dauerbetrieb

Agent läuft (24/7)
    │
    ├─ Monitoring: Health-Checks alle 30s
    ├─ Logging: Alle Aktionen protokollieren
    ├─ Alerting: Bei Fehlern benachrichtigen
    └─ Self-Healing: Bei Fehler neu starten
    │
    ▼
Systemd / Docker Restart-Policy
    │
    ├─ Bei Crash: Auto-Restart
    ├─ Bei OOM: Restart mit mehr Memory
    └─ Bei Hang: Timeout → Restart

Setup: Systemd für Dauerbetrieb

# /etc/systemd/system/ki-agent.service
[Unit]
Description=KI-Agent
After=network.target ollama.service

[Service]
Type=simple
User=ki-agent
WorkingDirectory=/opt/ki-agent
ExecStart=/usr/bin/python3 /opt/ki-agent/agent.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

# Ressourcen-Limits
MemoryMax=4G
CPUQuota=80%

[Install]
WantedBy=multi-user.target

# Aktivieren
sudo systemctl enable ki-agent
sudo systemctl start ki-agent

Setup: Docker für Dauerbetrieb

version: "3.8"

services:
  agent:
    build: ./agent
    restart: always  # Auto-Restart bei Fehler
    environment:
      - OLLAMA_URL=http://ollama:11434
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: '2.0'
        reservations:
          memory: 2G
          cpus: '1.0'
    networks:
      - agent_net

  ollama:
    image: ollama/ollama:latest
    restart: always
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - agent_net

volumes:
  ollama_data:

networks:
  agent_net:
    driver: bridge

Monitoring und Alerting

import time
import logging
from datetime import datetime

class AgentMonitor:
    """Monitoring für Agenten"""

    def __init__(self):
        self.logger = logging.getLogger("agent")
        self.error_count = 0
        self.last_success = datetime.now()

    def check_health(self):
        """Health-Check"""
        try:
            # Agent testen
            response = requests.get("http://localhost:8000/health", timeout=5)
            if response.status_code == 200:
                self.last_success = datetime.now()
                self.error_count = 0
                return True
        except Exception as e:
            self.error_count += 1
            self.logger.error(f"Health check failed: {e}")

            if self.error_count > 3:
                self.alert("Agent unhealthy", e)
                return False

    def alert(self, message, error):
        """Alert senden"""
        # E-Mail, Slack, PagerDuty, etc.
        send_notification(f"ALERT: {message}\nError: {error}")

    def run(self):
        """Monitoring-Loop"""
        while True:
            self.check_health()
            time.sleep(30)  # Alle 30 Sekunden

Fehlerbehandlung

class ResilientAgent:
    """Agent mit Fehlerbehandlung"""

    async def run_with_retry(self, task, max_retries=3):
        """Task mit Retry"""
        for attempt in range(max_retries):
            try:
                result = await self.process(task)
                return result
            except Exception as e:
                self.logger.warning(f"Attempt {attempt + 1} failed: {e}")

                if attempt == max_retries - 1:
                    self.alert(f"Task failed after {max_retries} attempts", e)
                    raise

                await asyncio.sleep(2 ** attempt)  # Exponential backoff

    async def process(self, task):
        """Task verarbeiten"""
        try:
            # Agent-Logik
            result = await self.execute(task)
            return result
        except OllamaError as e:
            # Ollama-Fehler: Modell neu laden?
            await self.handle_ollama_error(e)
            raise
        except MemoryError as e:
            # OOM: Weniger Kontext?
            await self.handle_oom(e)
            raise

Sicherheitshinweise

• Monitoring: Agent sollte sich selbst überwachen. Bei Anomalien alarmieren.
• Ressourcen-Limits: Memory/CPU-Limits verhindern, dass Agent alle Ressourcen frisst.
• Auto-Restart: Bei Fehlern automatisch neu starten, aber nicht endlos.
• Logging: Alle Aktionen protokollieren für Debugging und Audit. Siehe Protokollierung.
• Backup: Konfiguration und Daten regelmäßig sichern. Siehe Backup.

Typische Stolpersteine

• Kein Monitoring: Ohne Monitoring merkst Du nicht, wenn der Agent ausfällt.
• Memory-Leaks: Lang laufende Agenten können Memory-Leaks haben. Monitoring nötig.
• Kein Auto-Restart: Bei Fehler stoppt der Agent. Auto-Restart konfigurieren.
• Zu viele Restarts: Bei dauerhaftem Fehler restartet der Agent endlos. Max retries oder Circuit-Breaker.
• Keine Alerts: Bei Fehlern solltest Du benachrichtigt werden, nicht erst später merken.

Weiterführende Links

• Monitoring - Überwachung.
• Protokollierung - Logging.
• Docker - Für Deployment.
• KI-Agenten lokal betreiben - Übersicht.
• Backup - Datensicherung.
• Audit Logging - Audit-Trail.

Key Takeaways:

• Dauerbetrieb: Agent läuft 24/7, überwacht sich, erholt sich.
• Monitoring: Health-Checks, Logging, Alerting.
• Auto-Restart: Systemd oder Docker restart=always.
• Ressourcen-Limits verhindern OOM.
• Für Produktion: Monitoring und Alerting sind Pflicht.

FAQ

Quellen und weiterführende Literatur

• Systemd - Service-Management.
• Docker - Container.
• Ollama - Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert