Cron Jobs & Geplante Aufgaben

Automatisierung ist, wo KI-Agenten wirklich mächtig werden. Statt auf Benutzereingaben zu warten, kann sich dein OpenClaw-Agent selbst aufwecken, Systeme prüfen, Daten verarbeiten und nach einem von dir definierten Zeitplan handeln.

Diese Anleitung deckt alles über Scheduling in OpenClaw ab: Cron-Syntax, Heartbeat-Muster, praktische Beispiele und Best Practices für zuverlässige Automatisierung.

Was sind Cron-Jobs?

Cron ist ein zeitbasierter Job-Scheduler, der in Unix-ähnlichen Betriebssystemen zu finden ist. OpenClaw nutzt Cron, um Agent-Aktionen zu bestimmten Zeiten oder Intervallen auszulösen.

Häufige Anwendungsfälle

• Health Checks: Überprüfe, ob Systeme korrekt laufen
• Daten-Sync: Hole Daten in festen Intervallen von APIs
• Berichte: Generiere und sende tägliche/wöchentliche Zusammenfassungen
• Wartung: Räume alte Dateien auf oder bereinige Datenbanken
• Monitoring: Prüfe Website-Uptime oder Service-Status
• Backups: Starte Backup-Operationen automatisch
• Content-Publishing: Poste auf Blogs oder Social Media

Cron-Syntax-Grundlagen

Cron-Ausdrücke bestehen aus fünf Feldern, die Zeitintervalle repräsentieren:

* * * * *
│ │ │ │ │
│ │ │ │ └── Wochentag (0-7, Sonntag = 0 oder 7)
│ │ │ └──── Monat (1-12)
│ │ └────── Tag des Monats (1-31)
│ └──────── Stunde (0-23)
└────────── Minute (0-59)

Häufige Muster

Spezielle Zeichen

• * — Beliebiger Wert (Wildcard)
• , — Wertelistentrenner (z.B. 1,3,5)
• - — Bereich (z.B. 1-5 bedeutet 1,2,3,4,5)
• / — Schrittwerte (z.B. */5 bedeutet jede 5. Einheit)

Heartbeat-Muster

Ein Heartbeat ist ein geplanter Check, der verifiziert, ob deine Systeme gesund und funktionsfähig sind. Er ist die Grundlage zuverlässiger Automatisierung.

Basis Heartbeat-Konfiguration

# config.yaml - Heartbeat-Konfiguration
heartbeat:
  enabled: true
  # Alle 5 Minuten ausführen
  schedule: "*/5 * * * *"
  # Der Agent führt diesen Prompt planmäßig aus
  prompt: |
    Führe einen System-Health-Check durch:
    1. Prüfe, ob alle kritischen Services laufen
    2. Verifiziere, dass Festplattenspeicher > 20% ist
    3. Prüfe auf Fehler-Logs der letzten Stunde
    4. Melde gefundene Probleme
    5. Wenn alles gesund ist, logge "Alle Systeme funktionsfähig"

Heartbeat mit Aktionen

Ein fortgeschrittenerer Heartbeat, der bei erkannten Problemen handelt:

heartbeat:
  enabled: true
  schedule: "*/10 * * * *"
  prompt: |
    Führe die folgenden Health Checks durch:
    
    1. WEBSITE-CHECK:
       Nutze Browser, um zu verifizieren, dass https://mysite.com lädt
       Wenn Status nicht 200 ist, füge zur Problemliste hinzu
    
    2. API-CHECK:
       Nutze web_fetch zum Testen des API-Endpunkts
       Wenn Antwortzeit > 5s ist, füge zur Problemliste hinzu
    
    3. DISK-CHECK:
       Führe df -h aus und prüfe Datenträger-Nutzung
       Wenn eine Partition > 90% ist, füge zur Problemliste hinzu
    
    4. AKTION:
       Wenn Probleme gefunden wurden:
       - Sende Nachricht an Admin via Telegram
       - Logge die Probleme in heartbeat-errors.log
       - Füge Zeitstempel und Schweregrad hinzu
       
       Wenn keine Probleme:
       - Logge "Health Check bestanden" still

Geplante Aufgaben in OpenClaw

Jenseits von Heartbeats kannst du mehrere geplante Aufgaben für verschiedene Zwecke definieren.

Aufgaben-Konfiguration

# Mehrere geplante Aufgaben
scheduled_tasks:
  - name: "daily-report"
    schedule: "0 8 * * *"
    enabled: true
    prompt: |
      Generiere einen täglichen Zusammenfassungsbericht:
      1. Lese gestrige Aktivitäts-Logs
      2. Fasse wichtige Ereignisse und Metriken zusammen
      3. Sende Bericht an Team via E-Mail/Discord
      
  - name: "backup-check"
    schedule: "0 2 * * *"
    enabled: true
    prompt: |
      Verifiziere das Backup der letzten Nacht:
      1. Prüfe, ob Backup-Dateien existieren
      2. Verifiziere, dass Dateigrößen angemessen sind
      3. Teste eine Beispiel-Wiederherstellung falls nötig
      4. Melde Backup-Status
      
  - name: "api-sync"
    schedule: "0 */6 * * *"
    enabled: true
    prompt: |
      Synchronisiere Daten von externer API:
      1. Hole neue Datensätze von API
      2. Verarbeite und validiere Daten
      3. Speichere in lokaler Datenbank
      4. Logge Sync-Ergebnisse

Implementierungsbeispiele

Beispiel 1: Website-Monitoring

Prüfe deine Website alle 5 Minuten und alarmiere bei Ausfall:

scheduled_tasks:
  - name: "uptime-monitor"
    schedule: "*/5 * * * *"
    enabled: true
    prompt: |
      Prüfe Website-Uptime:
      1. Nutze web_fetch für GET https://example.com
      2. Wenn Status 200 ist: nichts tun (stiller Erfolg)
      3. Wenn Status nicht 200 oder Timeout:
         - Lese vorherigen Status aus /tmp/uptime-status.txt
         - Wenn Status von UP auf DOWN wechselt:
           * Sende Alarm: "Website DOWN: HTTP [status]"
           * Benachrichtige via konfiguriertem Kanal
         - Schreibe "DOWN" in /tmp/uptime-status.txt
      4. Wenn Wiederherstellung erkannt (war DOWN, jetzt UP):
         - Sende "Website wiederhergestellt" Benachrichtigung
         - Schreibe "UP" in /tmp/uptime-status.txt

Beispiel 2: Tägliche Datenverarbeitung

Verarbeite CSV-Dateien, die morgens in einen Ordner abgelegt werden:

scheduled_tasks:
  - name: "process-csv-files"
    schedule: "0 6 * * *"
    enabled: true
    prompt: |
      Verarbeite anstehende CSV-Dateien:
      1. Liste alle .csv-Dateien in /data/incoming/
      2. Für jede Datei:
         - Lese und validiere Inhalte
         - Transformiere Daten falls nötig
         - Importiere in Datenbank
         - Verschiebe verarbeitete Datei nach /data/processed/
         - Logge Verarbeitungsergebnisse
      3. Wenn keine Dateien gefunden, logge "Keine Dateien zu verarbeiten"
      4. Sende Zusammenfassung der verarbeiteten Dateien

Beispiel 3: Social-Media-Posting

Poste Content aus einer Queue zu optimalen Zeiten:

scheduled_tasks:
  - name: "social-post-morning"
    schedule: "0 9 * * *"
    enabled: true
    prompt: |
      Poste auf Social Media:
      1. Lese /data/social-queue/next-post.txt
      2. Wenn Datei existiert:
         - Extrahiere Post-Inhalt und Plattform
         - Nutze passende API/Tool zum Veröffentlichen
         - Verschiebe Post nach /data/social-queue/posted/
         - Logge Veröffentlichung
      3. Wenn keine Posts in Queue, prüfe RSS auf neuen Content
      
  - name: "social-post-afternoon"
    schedule: "0 15 * * *"
    enabled: true
    prompt: |
      Gleiche Aufgabe wie morgens für Nachmittags-Slot

Cron mit Docker betreiben

Docker-Container haben standardmäßig kein Cron. Hier sind drei Ansätze:

Option 1: Host-Cron (Empfohlen)

Nutze das Cron-System des Hosts, um Container-Aufgaben zu triggern:

# Auf dem Host, crontab bearbeiten: crontab -e
# Füge Zeilen hinzu, um OpenClaw-Aufgaben zu triggern:

*/5 * * * * docker exec openclaw-agent openclaw heartbeat
0 8 * * * docker exec openclaw-agent openclaw task daily-report

Option 2: Cron im Container

Füge Cron zu deinem Docker-Image hinzu:

# Dockerfile
FROM openclaw/base:latest

# Installiere Cron
RUN apt-get update && apt-get install -y cron

# Füge Crontab hinzu
COPY crontab /etc/cron.d/openclaw
RUN chmod 0644 /etc/cron.d/openclaw

# Starte Cron mit OpenClaw
CMD cron && openclaw start

Option 3: Ofelia-Scheduler

Nutze Ofelia für Docker-native Job-Planung:

# docker-compose.yml
version: '3'
services:
  ofelia:
    image: mcuadros/ofelia:latest
    command: daemon --config=/etc/ofelia/config.ini
    volumes:
      - ./ofelia.ini:/etc/ofelia/config.ini
      - /var/run/docker.sock:/var/run/docker.sock
    
  openclaw:
    image: openclaw/agent:latest
    container_name: openclaw-agent

# ofelia.ini
[job-exec "heartbeat"]
schedule = */5 * * * *
container = openclaw-agent
command = openclaw heartbeat

[job-exec "daily-report"]
schedule = 0 8 * * *
container = openclaw-agent
command = openclaw task daily-report

Best Practices

Scheduling-Richtlinien

• Verteile die Last: Plane nicht alle Aufgaben zur gleichen Minute
• Nutze angemessene Intervalle: Jede Minute ist meist überflüssig; alle 5-15 Minuten ist oft ausreichend
• Berücksichtige Zeitzonen: Cron nutzt Systemzeit; dokumentiere die Zeitzone deines Servers
• Vermeide Mitternacht: Viele Systeme sind um 00:00 Uhr beschäftigt; wähle Nebenzeiten

Fehlerbehandlung

• Protokolliere immer Aufgaben-Ergebnisse, sowohl Erfolg als auch Fehler
• Richte Alarme für kritische Aufgaben-Fehler ein
• Nutze Exit-Codes, um Erfolg/Fehler anzuzeigen
• Implementiere Retry-Logik für vorübergehende Fehler
• Behalte einen Aufgaben-Ausführungsverlauf für Debugging

Idempotenz

Entwirf Aufgaben so, dass sie mehrfach sicher ausgeführt werden können:

• Prüfe, ob Arbeit bereits erledigt wurde, bevor du wiederholst
• Nutze Datei-Locks oder Datenbank-Flags, um doppelte Verarbeitung zu verhindern
• Mache Daten-Operationen wo möglich atomar
• Verfolge Status zwischen Ausführungen

Ressourcen-Management

• Begrenze gleichzeitige geplante Aufgaben
• Setze Timeouts, um unkontrollierte Prozesse zu verhindern
• Überwache Speicher- und CPU-Nutzung
• Räume temporäre Dateien nach Aufgaben-Abschluss auf

Testen deiner Cron-Setup

Cron-Ausdruck validieren

Teste deine Cron-Syntax vor dem Deploy:

# Nutze Online-Validatoren oder Kommandozeilen-Tools
# Installiere croniter für Python-Validierung:
pip install croniter

# Teste Ausdruck
python3 -c "from croniter import croniter; 
print(croniter('*/5 * * * *').get_next())"

Manuelles Aufgaben-Testing

Führe deine geplante Aufgabe manuell aus, bevor du automatisiert:

# Teste den exakten Befehl, den Cron ausführen wird
openclaw task daily-report --dry-run

# Oder führe den Prompt direkt in einer interaktiven Session aus
# um zu verifizieren, dass er wie erwartet funktioniert

Log-Monitoring

Richte Log-Tracking für deine geplanten Aufgaben ein:

# Zeige aktuelle Cron-Logs
tail -f /var/log/cron.log

# Oder in Docker:
docker logs openclaw-agent --follow | grep "scheduled"

Fehlerbehebung

Aufgabe läuft nicht

• Syntax prüfen: Verifiziere, dass Cron-Ausdruck gültig ist
• Aufgaben aktivieren: Bestätige, dass enabled: true gesetzt ist
• Zeitzonen: Verifiziere, dass Systemzeitzone mit Erwartungen übereinstimmt
• Service läuft: Stelle sicher, dass OpenClaw-Daemon aktiv ist
• Logs prüfen: Suche nach Parsing- oder Ausführungsfehlern

Aufgaben laufen zu häufig

• Prüfe Schrittwerte doppelt: */1 vs */5
• Verifiziere, dass keine doppelten Einträge existieren
• Prüfe, ob mehrere Scheduler laufen

Ressourcen-Erschöpfung

• Aufgaben können überlappen, wenn vorheriger Lauf nicht beendet ist
• Implementiere File-Locking, um gleichzeitige Ausführungen zu verhindern
• Erhöhe Intervall oder optimiere Aufgaben-Performance
• Erwäge, große Aufgaben in kleinere Chunks aufzuteilen

Zusammenfassung

Cron-Jobs und geplante Aufgaben verwandeln deinen OpenClaw-Agenten von einem reaktiven Assistenten in ein proaktives Automatisierungssystem. Meistere Cron-Syntax, implementiere Heartbeat-Muster für Monitoring und entwerfe zuverlässige Aufgaben, die ohne menschliches Zutun laufen.

Starte mit einfachen Health-Checks, baue dann zu komplexen Automatisierungs-Workflows auf. Teste immer gründlich, behandle Fehler elegant und überwache deine geplanten Aufgaben, um sicherzustellen, dass sie weiterhin reibungslos laufen.