FAQ: Automatisierung und Deployment

Du hast einen Bot gebaut. Er funktioniert. Lokal. Auf deinem Rechner. Solange dein Laptop offen ist.

Das reicht nicht.

Automatisierung bedeutet: Dein System läuft, auch wenn du schläfst. Deployment bedeutet: Es läuft nicht auf deinem Rechner, sondern auf einem Server. Hier sind die Antworten auf die häufigsten Fragen.

Was ist ein Cron-Job?

Ein Cron-Job ist ein geplanter Befehl, der zu festgelegten Zeiten automatisch ausgeführt wird. Benannt nach dem Unix-Dienst cron (von griechisch chronos — Zeit).

Du sagst dem System: "Führe dieses Script jeden Tag um 9:00 Uhr aus." Das System tut es. Jeden Tag. Ohne Ausnahme. Ohne Erinnerung.

Cron-Syntax

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

Beispiele

Cron-Ausdruck	Bedeutung
`0 9 * * *`	Jeden Tag um 9:00
`0 9,18 * * *`	Jeden Tag um 9:00 und 18:00
`/30 * * *`	Alle 30 Minuten
`0 9 * * 1-5`	Montag bis Freitag um 9:00
`0 0 1 * *`	Am 1. jedes Monats um Mitternacht

Wichtig: Server laufen meistens in UTC. Berlin ist UTC+1 (Winter) oder UTC+2 (Sommer). Rechne entsprechend um.

Nutze crontab.guru zum Testen deiner Ausdrücke.

Was ist eine Queue?

Eine Queue (Warteschlange) ist ein Puffer zwischen Content-Erstellung und Veröffentlichung. Statt Content sofort zu posten, legst du ihn in die Queue — und ein separater Prozess veröffentlicht ihn nach Zeitplan.

Warum eine Queue?

Entkopplung — Content-Erstellung und Posting sind unabhängig
Puffer — Wenn die AI mal Müll produziert, kannst du ihn vor der Veröffentlichung entfernen
Gleichmäßigkeit — Egal wie viel Content du erstellst, es wird gleichmäßig verteilt
Ausfallsicherheit — Wenn Telegram kurz down ist, geht kein Content verloren

Einfache Queue-Implementierung

import json
from pathlib import Path

QUEUE_FILE = "queue.json"

def add_to_queue(post: dict):
    queue = load_queue()
    queue.append(post)
    save_queue(queue)

def get_next_post() -> dict:
    queue = load_queue()
    if not queue:
        return None
    post = queue.pop(0)
    save_queue(queue)
    return post

def load_queue() -> list:
    if Path(QUEUE_FILE).exists():
        return json.loads(Path(QUEUE_FILE).read_text())
    return []

def save_queue(queue: list):
    Path(QUEUE_FILE).write_text(json.dumps(queue, ensure_ascii=False))

Für professionellere Setups: Redis, RabbitMQ oder Celery. Aber für den Anfang reicht eine JSON-Datei.

Was ist Railway?

Railway ist eine Cloud-Plattform, auf der du Code deployen kannst — ohne dich mit Servern, Networking oder Infrastruktur beschäftigen zu müssen.

Du pushst deinen Code, Railway baut und startet ihn. Fertig.

Vorteile

Einfach — Git-Push und es läuft
Günstig — Free-Tier verfügbar, danach ~$5/Monat
Schnell — Deployment in unter 2 Minuten
Umgebungsvariablen — Secrets sicher verwalten

Alternativen

Plattform	Preis	Stärke
Railway	Free / ~$5/Mo	Einfachheit
Render	Free / ~$7/Mo	Statische Sites + Services
Fly.io	Free / ~$5/Mo	Edge-Deployment
VPS (Hetzner)	~$4/Mo	Volle Kontrolle
Netlify	Free / ~$19/Mo	Ideal für Next.js/Jamstack

Wie deploye ich auf Railway?

Schritt für Schritt

1. Account erstellen Gehe zu railway.app und erstelle einen Account.

2. Neues Projekt

Dashboard → New Project → Deploy from GitHub Repo
Repository auswählen und verbinden

3. Umgebungsvariablen setzen

Projekt → Variables → Add Variable
TELEGRAM_BOT_TOKEN = dein Token
CHANNEL_ID = deine Channel-ID
Weitere Variablen nach Bedarf

4. Build-Einstellungen Railway erkennt automatisch Python, Node.js und andere Sprachen. Falls nicht:

Procfile erstellen:
```
worker: python main.py
```

Oder railway.toml:

[build]
builder = "nixpacks"

[deploy]
startCommand = "python main.py"

5. Deploy Push zu GitHub → Railway baut automatisch → Service läuft.

Brauche ich einen VPS?

Für die meisten Vibe-Coding-Projekte: Nein. Railway, Render oder Fly.io reichen völlig.

Ein VPS (Virtual Private Server) lohnt sich, wenn:

Du volle Kontrolle über den Server brauchst
Du mehrere Projekte auf einem Server betreiben willst
Du Kosten optimieren willst (ein $4-VPS kann viel leisten)
Du spezielle Software installieren musst

VPS-Grundlagen

# Verbindung zum VPS:
ssh user@dein-server-ip

# Python installieren:
sudo apt update && sudo apt install python3 python3-pip

# Projekt klonen:
git clone https://github.com/dein-user/dein-repo.git

# Abhängigkeiten installieren:
cd dein-repo
pip3 install -r requirements.txt

# Service als Daemon starten:
nohup python3 main.py &

# Oder besser — mit systemd:
sudo systemctl enable mein-bot
sudo systemctl start mein-bot

Empfohlene VPS-Anbieter: Hetzner (günstig, deutsch), DigitalOcean (gut dokumentiert), Contabo (sehr günstig).

Wie überwache ich mein System?

Monitoring ist kein Luxus — es ist Pflicht. Wenn dein Bot ausfällt und du es nicht merkst, postet er tagelang nichts. Deine Abonnenten bemerken es. Du nicht.

Einfaches Monitoring

1. Health-Check-Endpoint

from flask import Flask

app = Flask(__name__)

@app.route("/health")
def health():
    return {"status": "ok", "timestamp": time.time()}

2. Externer Monitor Dienste wie UptimeRobot (kostenlos) oder Better Uptime pingen deinen Endpoint regelmäßig und alarmieren dich bei Ausfall.

3. Telegram-Benachrichtigungen Sende dir selbst eine Nachricht, wenn etwas schiefgeht:

def notify_admin(message: str):
    admin_chat_id = os.environ.get("ADMIN_CHAT_ID")
    requests.get(
        f"https://api.telegram.org/bot{token}/sendMessage",
        params={"chat_id": admin_chat_id, "text": f"⚠ {message}"}
    )

4. Logging Alles loggen. Immer. Ohne Ausnahme:

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.FileHandler("bot.log"),
        logging.StreamHandler()
    ]
)

Wie manage ich mehrere Kanäle?

Ein Bot, mehrere Kanäle — das ist Standard. So organisierst du es:

Konfigurationsdatei

CHANNELS = {
    "tech": {
        "id": "-100111111111",
        "schedule": "0 9,18 * * *",
        "skill": "tech-post"
    },
    "ai-news": {
        "id": "-100222222222",
        "schedule": "0 10,14,20 * * *",
        "skill": "ai-news-post"
    },
    "tutorials": {
        "id": "-100333333333",
        "schedule": "0 12 * * 1,3,5",
        "skill": "tutorial-post"
    }
}

Separierung

Ein Bot für alle Kanäle (einfacher zu verwalten)
Separate Queues pro Kanal (Content vermischt sich nicht)
Separate Skills pro Kanal (jeder Kanal hat seinen Ton)
Zentrales Logging (ein Dashboard für alles)

Welche Posting-Strategie ist optimal?

Das hängt von deinem Kanal ab, aber hier sind bewährte Muster:

Frequenz

Kanaltyp	Posts/Tag	Beste Zeiten (MEZ)
News	3-5	8:00, 12:00, 17:00, 20:00
Tutorials	1	10:00 oder 14:00
Reviews	1	18:00
Memes/Unterhaltung	2-3	12:00, 19:00, 22:00

Regeln

Konsistenz schlägt Quantität — Lieber 1 Post/Tag zuverlässig als 5 Posts/Tag unregelmäßig
Qualität vor Speed — Ein durchdachter Post > drei AI-Slop-Posts
Queue-Puffer — Halte immer 3-5 Posts in der Queue als Reserve
Wochenenden — Weniger posten oder Evergreen-Content nutzen

Wie optimiere ich die Kosten?

Vibe Coding muss nicht teuer sein. So minimierst du Ausgaben:

AI-Kosten

Kleineres Modell für Routine — Haiku/GPT-4o-mini für einfache Posts
Großes Modell für Qualität — Opus/GPT-4 nur für wichtige Inhalte
Caching — Wiederhole keine Recherche, die du schon gemacht hast

Hosting-Kosten

Railway Free-Tier — 500 Stunden/Monat
Cron statt Always-On — Starte den Service nur, wenn er etwas tun muss
Shared VPS — Ein $4-Server für mehrere Projekte

Gesamtrechnung (Minimum)

Posten	Kosten/Monat
AI-Tool (Claude/Cursor)	$20
Hosting (Railway Free)	$0
Exa (Free-Tier)	$0
Gesamt	$20

Und selbst die $20 kannst du auf $0 senken, wenn du Codex CLI mit Free-Tier-APIs nutzt. Dann zahlst du: nichts. Null. Nada.

Backups — brauche ich die?

Ja. Punkt. Keine Diskussion.

Was sichern?

Code — Git (ist schon ein Backup)
Queue/Content — JSON-Dateien, Datenbank
Konfiguration — .env-Variablen (sicher notieren)
Skills — Liegen im Git-Repo, also gesichert

Wie sichern?

# Tägliches Backup der Queue:
cp queue.json "backups/queue_$(date +%Y%m%d).json"

# Git-Push als Backup:
git add . && git commit -m "Daily backup" && git push

Oder lass die AI ein automatisches Backup-Script erstellen. Das ist ein 5-Minuten-Prompt.

Weiter geht's mit den Tool-Guides — starte mit Claude Code.