# Deployment 24/7: Vom lokalen Rechner in die Cloud

> Deploye deinen Bot auf Railway, VPS oder einem alten Mac — damit er rund um die Uhr läuft.

- URL: https://thevibe-coding.de/kurs/deployment-24-7
- Typ: kurs | Veroeffentlicht: 2026-02-24 | Aktualisiert: 2026-02-24
- Autor: VIBE CODING | Site: VIBE CODING — thevibe-coding.de

---

# Deployment 24/7: Vom lokalen Rechner in die Cloud

Dein Bot funktioniert lokal perfekt. Dein Queue-System läuft. Deine Skills sind konfiguriert. Aber sobald du deinen Laptop zuklappst, steht alles still. Zeit, das zu ändern. In dieser Lektion bringen wir dein System in die Cloud — damit es 24 Stunden am Tag, 7 Tage die Woche läuft.

## Die drei Deployment-Optionen

### Option 1: Der alte Rechner

**Was:** Nutze einen alten Computer (Mac Mini, alter Laptop, Raspberry Pi) als dedizierten Server.

**Vorteile:**
- Keine laufenden Kosten
- Volle Kontrolle über Hardware und Software
- Keine Abhängigkeit von Cloud-Anbietern
- Perfekt zum Lernen

**Nachteile:**
- Stromkosten
- Muss immer eingeschaltet sein
- Internetausfall = Bot-Ausfall
- Kein automatisches Backup
- Kein einfaches Skalieren

**Für wen:** Hobbyisten, die experimentieren wollen und einen alten Rechner herumliegen haben.

**Setup:**
```bash
# Auf dem alten Rechner
git clone dein-projekt.git
cd dein-projekt
npm install

# Cron-Jobs einrichten
crontab -e
# ... deine Cron-Jobs hinzufügen

# Sicherstellen, dass der Prozess nach Neustart weiterläuft
# Option A: systemd Service (Linux)
# Option B: launchd (macOS)
# Option C: pm2 (plattformübergreifend)
pm2 start bot.js --name "content-bot"
pm2 save
pm2 startup
```

### Option 2: Railway (Empfohlen)

**Was:** Railway ist eine Cloud-Plattform, die Deployments absurd einfach macht. Du pushst Code — Railway erledigt den Rest.

**Vorteile:**
- Deployment in unter 5 Minuten
- Automatisches HTTPS
- Umgebungsvariablen-Verwaltung
- Automatische Deployments bei Git Push
- Eingebautes Monitoring
- Kostenlose Starter-Tier

**Nachteile:**
- Kosten bei intensiver Nutzung
- Abhängigkeit von einem Anbieter
- Weniger Kontrolle als bei einem VPS

**Für wen:** Die meisten Nutzer. Ernsthaft — wenn du nicht weißt, was du nehmen sollst, nimm Railway.

### Option 3: VPS (Virtual Private Server)

**Was:** Ein virtueller Server bei Hetzner, DigitalOcean, Linode oder ähnlichen Anbietern.

**Vorteile:**
- Maximale Kontrolle
- Günstig bei hoher Nutzung
- Keine Vendor-Lock-in-Gefahr
- Root-Zugang für alles

**Nachteile:**
- Du musst alles selbst konfigurieren
- Sicherheitsupdates sind deine Verantwortung
- SSH, Firewall, Nginx — alles Handarbeit
- Nicht für Anfänger

**Für wen:** Entwickler mit Linux-Erfahrung, die maximale Kontrolle wollen.

## Railway: Schritt für Schritt

Railway ist die empfohlene Option. Hier ist die komplette Anleitung:

### Schritt 1: Code vorbereiten

Dein Projekt braucht eine klare Struktur:

```
mein-bot/
├── bot.js              # Hauptdatei
├── package.json        # Dependencies
├── queue.json          # Post-Queue
├── .env.example        # Vorlage für Umgebungsvariablen
├── .claude/
│   └── commands/       # Deine Skills
├── scripts/
│   ├── generate.sh     # Post-Erstellung
│   ├── publish.sh      # Veröffentlichung
│   └── review.sh       # Review-Prozess
└── Procfile            # Railway-Konfiguration
```

**Procfile erstellen:**
```
worker: node bot.js
```

**package.json prüfen:**
```json
{
  "name": "content-bot",
  "version": "1.0.0",
  "scripts": {
    "start": "node bot.js",
    "generate": "node scripts/generate.js",
    "publish": "node scripts/publish.js"
  },
  "dependencies": {
    "node-cron": "^3.0.0",
    "grammy": "^1.20.0"
  }
}
```

### Schritt 2: Zu GitHub pushen

```bash
git init
git add .
git commit -m "Initial commit: Content-Bot"
git remote add origin https://github.com/dein-name/content-bot.git
git push -u origin main
```

**Wichtig:** Stelle sicher, dass `.env` in `.gitignore` steht! Keine Geheimnisse im Repository.

```bash
# .gitignore
.env
node_modules/
logs/
```

### Schritt 3: Railway verbinden

1. Gehe zu [railway.app](https://railway.app)
2. Registriere dich (GitHub-Login empfohlen)
3. Klicke auf **"New Project"**
4. Wähle **"Deploy from GitHub repo"**
5. Wähle dein Repository aus
6. Railway erkennt automatisch die Projektstruktur

### Schritt 4: Umgebungsvariablen setzen

In Railway → Projekt → Variables:

```
TELEGRAM_BOT_TOKEN=dein-bot-token
ANTHROPIC_API_KEY=dein-claude-api-key
EXA_API_KEY=dein-exa-api-key
TIMEZONE=Europe/Berlin
PUBLISH_TIMES=09:00,13:00,18:00
```

**Niemals** API-Keys im Code speichern. Immer über Umgebungsvariablen.

### Schritt 5: Deployment verifizieren

Railway startet automatisch das Deployment. Du siehst:

```
==> Building...
==> Installing dependencies...
==> Starting worker: node bot.js
==> Deployment successful ✓
```

Prüfe die Logs:
- Startet der Bot korrekt?
- Werden die Cron-Jobs registriert?
- Gibt es Fehlermeldungen?

### Schritt 6: Automatische Deployments

Ab jetzt: Jeder Push zu GitHub löst automatisch ein neues Deployment aus.

```bash
# Lokale Änderung
git add .
git commit -m "Neuer Skill: /weekly-report"
git push
# → Railway deployed automatisch in ~30 Sekunden
```

## Kostenübersicht

### Minimale Konfiguration (~15-20€/Monat)

- **Railway Hobby Plan:** ~5€/Monat
- **Claude API:** ~5-10€/Monat (bei 5-10 Posts/Tag)
- **Exa API:** ~2-5€/Monat
- **Telegram Bot:** Kostenlos

**Geeignet für:** 1 Bot, 5-10 Posts pro Tag, 1 Plattform

### Optimierte Konfiguration (~3€/Monat)

- **Railway:** Minimale Nutzung, Cron statt Always-On
- **Claude API:** Optimierte Prompts, weniger Tokens
- **Exa API:** Nur wenn nötig, gecachte Ergebnisse

**Tricks zur Kostenoptimierung:**
- Nutze `claude --model sonnet` (oder für einfache Posts `--model haiku`) statt Opus für Routineaufgaben — kaum Qualitätsverlust, deutlich geringere Kosten
- Cache Exa-Ergebnisse lokal und wiederhole Suchen nur wöchentlich
- Batch-Generierung (7 Posts auf einmal) statt täglicher Einzelgenerierung
- Nutze Railway's Sleep-Feature — der Bot schläft, wenn er nicht gebraucht wird

### Enterprise-Konfiguration (~90€/Monat)

- **Railway Pro:** ~20€/Monat
- **Claude API:** ~40-50€/Monat (bei 50+ Posts/Tag, Opus-Modell)
- **Exa API:** ~10-15€/Monat (intensive Recherche)
- **Monitoring:** ~5€/Monat (z.B. Better Uptime)

**Geeignet für:** Mehrere Bots, 50+ Posts pro Tag, Multi-Plattform

## Monitoring und Gesundheitschecks

Dein Bot läuft in der Cloud. Aber woher weißt du, dass er funktioniert?

### Einfaches Monitoring: Health Check

Füge deinem Bot einen Health-Check-Endpunkt hinzu:

```javascript
const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/health') {
    res.writeHead(200);
    res.end(JSON.stringify({
      status: 'ok',
      uptime: process.uptime(),
      lastPost: lastPostTimestamp,
      queueSize: queue.posts.length
    }));
  }
});

server.listen(process.env.PORT || 3000);
```

### Telegram-Benachrichtigungen

Lass deinen Bot dich über wichtige Ereignisse informieren:

```javascript
async function notifyAdmin(message) {
  await bot.api.sendMessage(ADMIN_CHAT_ID, `🔔 Bot-Status: ${message}`);
}

// Beispiele:
notifyAdmin("Post veröffentlicht: 'Vibe Coding Basics'");
notifyAdmin("⚠️ Fehler: API-Limit erreicht");
notifyAdmin("Queue leer — neue Posts generieren!");
```

### Täglicher Status-Report

Erstelle einen automatischen täglichen Bericht:

```javascript
// Jeden Abend um 21:00
cron.schedule('0 21 * * *', async () => {
  const report = {
    postsToday: getPublishedToday(),
    queueSize: queue.posts.filter(p => p.status === 'approved').length,
    nextPost: getNextScheduled(),
    errors: getTodayErrors()
  };

  await notifyAdmin(formatReport(report));
});
```

## Backups

Cloud-Deployments können fehlschlagen. Daten können verloren gehen. Backups sind Pflicht.

### Was sichern?

1. **queue.json** — Deine Post-Queue (das Herzstück)
2. **STYLE.md** — Dein Stil-Guide
3. **Skills & Commands** — Deine `.claude/skills/`- und `.claude/commands/`-Ordner
4. **Logs** — Für Fehleranalyse
5. **Konfiguration** — Umgebungsvariablen (separat und sicher!)

### Automatisches Backup

```bash
#!/bin/bash
# backup.sh — Tägliches Backup

BACKUP_DIR="/backups/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"

cp queue.json "$BACKUP_DIR/"
cp STYLE.md "$BACKUP_DIR/"
cp -r .claude/skills .claude/commands "$BACKUP_DIR/" 2>/dev/null
cp -r logs "$BACKUP_DIR/"

# Alte Backups löschen (älter als 30 Tage)
find /backups -type d -mtime +30 -exec rm -rf {} +
```

### GitHub als Backup

Die einfachste Backup-Strategie: Committe regelmäßig deine `queue.json`:

```bash
# In deinem Cron-Job
git add queue.json
git commit -m "Queue-Backup: $(date +%Y-%m-%d_%H:%M)"
git push
```

So hast du ein vollständiges Versionshistorie deiner Queue — und kannst jederzeit zu einem früheren Stand zurückkehren.

## Checkliste: Deployment-Readiness

Bevor du deployest, prüfe:

- [ ] Alle API-Keys in Umgebungsvariablen (nicht im Code)
- [ ] `.env` in `.gitignore`
- [ ] `Procfile` oder `package.json start`-Script vorhanden
- [ ] Health-Check-Endpunkt eingebaut
- [ ] Fehlerbehandlung für API-Ausfälle
- [ ] Telegram-Benachrichtigungen für Fehler
- [ ] Backup-Strategie definiert
- [ ] Logging aktiviert
- [ ] Kosten kalkuliert und Budget gesetzt

## Zusammenfassung

- **Alter Rechner:** Kostenlos, aber unzuverlässig — gut zum Experimentieren
- **Railway:** Die beste Option für die meisten — einfach, schnell, bezahlbar
- **VPS:** Maximale Kontrolle für erfahrene Entwickler
- **Kosten:** Von 3€ bis 90€/Monat — je nach Bedarf
- **Monitoring:** Health Checks + Telegram-Benachrichtigungen + Täglicher Report
- **Backups:** Queue, Style, Skills — täglich sichern

Dein Bot läuft jetzt 24/7. Als Nächstes lernen wir die [5-Phasen-Pipeline](/kurs/fuenf-phasen-pipeline) — damit der Content, den dein Bot produziert, auch wirklich gut ist.