# Einfaches Deployment OHNE Docker Hub

## Warum diese Methode?

- ✅ Kein Docker Hub Account nötig
- ✅ Keine Gefahr, dass andere dein Image sehen
- ✅ Schneller und einfacher
- ✅ Perfekt für einen einzelnen Server

## Deployment-Prozess

### Schritt 1: Backend zum Server kopieren

**Option A: Mit SCP (Windows PowerShell oder Git Bash)**

```bash
# Temporäres Archiv erstellen (ohne unnötige Dateien)
cd "E:\Dokumente\05_Skrift\Frontend_Backend_Konfigurator\Docker Backend"

# Zip erstellen
tar -czf skrift-backend.tar.gz \
  --exclude='node_modules' \
  --exclude='output' \
  --exclude='cache' \
  --exclude='.git' \
  --exclude='*.md' \
  --exclude='bruno-tests' \
  --exclude='test-*.js' \
  --exclude='generate-*.js' \
  src/ fonts/ package.json package-lock.json Dockerfile docker-compose.yml .dockerignore

# Zum Server kopieren
scp skrift-backend.tar.gz root@DEINE-SERVER-IP:/tmp/

# Auf Server entpacken
ssh root@DEINE-SERVER-IP << 'ENDSSH'
  mkdir -p /opt/skrift-backend
  cd /opt/skrift-backend
  tar -xzf /tmp/skrift-backend.tar.gz
  rm /tmp/skrift-backend.tar.gz
ENDSSH
```

**Option B: Mit RSYNC (empfohlen, wenn verfügbar)**

```bash
# Direkt synchronisieren (nur geänderte Dateien)
rsync -avz --progress \
  --exclude='node_modules' \
  --exclude='output' \
  --exclude='cache' \
  --exclude='.git' \
  --exclude='*.md' \
  --exclude='bruno-tests' \
  --exclude='test-*.js' \
  --exclude='generate-*.js' \
  "/e/Dokumente/05_Skrift/Frontend_Backend_Konfigurator/Docker Backend/" \
  root@DEINE-SERVER-IP:/opt/skrift-backend/
```

**Option C: Mit WinSCP (GUI)**

1. WinSCP herunterladen und installieren
2. Verbindung zu deinem Server herstellen
3. Verzeichnis erstellen: `/opt/skrift-backend`
4. Diese Ordner hochladen:
   - `src/` (kompletter Ordner)
   - `fonts/` (kompletter Ordner)
   - `package.json`
   - `package-lock.json`
   - `Dockerfile`
   - `docker-compose.yml`
   - `.dockerignore`

### Schritt 2: Auf dem Server einrichten

Per SSH auf den Server:

```bash
ssh root@DEINE-SERVER-IP

# Ins Backend-Verzeichnis
cd /opt/skrift-backend

# .env Datei erstellen (WICHTIG!)
cat > .env << 'EOF'
SCRIPTALIZER_LICENSE_KEY=f9918b40-d11c-11f0-b558-0800200c9a66
SCRIPTALIZER_ERR_FREQUENCY=0
BATCH_SIZE=30
CACHE_LIFETIME_HOURS=2
RATE_LIMIT_PER_MINUTE=2
NODE_ENV=production
PORT=4000
EOF

# Berechtigungen setzen
chmod 600 .env

# Output-Verzeichnis für N8N erstellen
mkdir -p /var/skrift-output
chmod 755 /var/skrift-output

# Docker Image bauen und Container starten
docker-compose up -d --build

# Logs ansehen (Ctrl+C zum Beenden)
docker-compose logs -f
```

### Schritt 3: Testen

```bash
# Health-Check auf dem Server
curl http://localhost:4000/health

# Sollte zurückgeben:
# {"status":"ok","timestamp":"2026-01-03T..."}
```

### Schritt 4: Nginx Proxy Manager einrichten

1. Öffne Nginx Proxy Manager (z.B. `http://dein-server.de:81`)
2. Login mit Admin-Credentials
3. "Proxy Hosts" → "Add Proxy Host"

**Details Tab:**
- Domain Names: `backend.deine-domain.de` (oder `skrift-backend.deine-domain.de`)
- Scheme: `http`
- Forward Hostname/IP: `skrift-backend` (der Docker Container Name!)
- Forward Port: `4000`
- Cache Assets: ✓ aktivieren
- Block Common Exploits: ✓ aktivieren
- Websockets Support: nicht aktivieren

**SSL Tab:**
- SSL Certificate: "Request a new SSL Certificate"
- Force SSL: ✓ aktivieren
- Email Address: deine-email@domain.de
- I Agree to the Terms: ✓ aktivieren

4. "Save" klicken

### Schritt 5: Finaler Test

Von deinem lokalen Rechner:

```bash
curl https://backend.deine-domain.de/health
```

## Updates durchführen

Wenn du Code-Änderungen gemacht hast:

```bash
# 1. Lokal: Neue Version zum Server kopieren
rsync -avz --progress \
  --exclude='node_modules' \
  --exclude='output' \
  --exclude='cache' \
  "/e/Dokumente/05_Skrift/Frontend_Backend_Konfigurator/Docker Backend/" \
  root@DEINE-SERVER-IP:/opt/skrift-backend/

# 2. Auf Server: Container neu bauen
ssh root@DEINE-SERVER-IP "cd /opt/skrift-backend && docker-compose up -d --build"

# 3. Logs prüfen
ssh root@DEINE-SERVER-IP "cd /opt/skrift-backend && docker-compose logs -f"
```

## Automatisches Update-Script

Erstelle eine Datei `update.sh` auf deinem lokalen Rechner:

```bash
#!/bin/bash

SERVER="root@DEINE-SERVER-IP"
REMOTE_PATH="/opt/skrift-backend"
LOCAL_PATH="/e/Dokumente/05_Skrift/Frontend_Backend_Konfigurator/Docker Backend"

echo "Syncing files to server..."
rsync -avz --progress \
  --exclude='node_modules' \
  --exclude='output' \
  --exclude='cache' \
  --exclude='.git' \
  "$LOCAL_PATH/" \
  "$SERVER:$REMOTE_PATH/"

echo "Rebuilding container on server..."
ssh $SERVER "cd $REMOTE_PATH && docker-compose up -d --build"

echo "Done! Checking logs..."
ssh $SERVER "cd $REMOTE_PATH && docker-compose logs --tail=50"
```

Dann einfach ausführen:
```bash
bash update.sh
```

## Vorteile dieser Methode

✅ **Privat**: Nur auf deinem Server, niemand sonst kann es sehen
✅ **Einfach**: Keine Docker Hub Registrierung nötig
✅ **Schnell**: Direkt auf dem Server gebaut
✅ **Sicher**: Keine Credentials in der Cloud
✅ **Flexibel**: Änderungen sofort deployen

## Troubleshooting

### Verbindung fehlgeschlagen
```bash
# SSH-Verbindung testen
ssh root@DEINE-SERVER-IP

# Falls Fehler: SSH-Key einrichten
ssh-keygen -t rsa -b 4096
ssh-copy-id root@DEINE-SERVER-IP
```

### Container startet nicht
```bash
# Logs prüfen
ssh root@DEINE-SERVER-IP "cd /opt/skrift-backend && docker-compose logs"

# Häufige Probleme:
# - .env fehlt → Schritt 2 wiederholen
# - Fonts fehlen → fonts/ Ordner hochladen
# - Port 4000 belegt → docker-compose.yml anpassen
```

### Nginx Proxy erreicht Container nicht
```bash
# Prüfen ob Container im richtigen Netzwerk ist
ssh root@DEINE-SERVER-IP "docker network ls"
ssh root@DEINE-SERVER-IP "docker network inspect skrift-network"

# Container Name prüfen
ssh root@DEINE-SERVER-IP "docker ps | grep skrift"

# In Nginx Proxy Manager: Forward Hostname = "skrift-backend" (Container-Name)
```

### Build dauert zu lange
```bash
# Cache löschen und neu bauen
ssh root@DEINE-SERVER-IP "cd /opt/skrift-backend && docker-compose build --no-cache"
```

## Sicherheit

- `.env` Datei wird **nur** auf dem Server erstellt (nicht hochgeladen)
- `.dockerignore` verhindert Upload von sensiblen Dateien
- Nur notwendige Ports werden geöffnet (4000 nur intern)
- Nginx Proxy Manager mit SSL-Verschlüsselung
- Rate Limiting ist bereits im Backend implementiert

## Backup

```bash
# Auf dem Server
# 1. Code-Backup
tar -czf /root/skrift-backend-backup-$(date +%Y%m%d).tar.gz /opt/skrift-backend

# 2. Output-Dateien Backup
tar -czf /root/skrift-output-backup-$(date +%Y%m%d).tar.gz /var/skrift-output

# 3. Zu lokalem Rechner herunterladen
scp root@DEINE-SERVER-IP:/root/skrift-*-backup-*.tar.gz ./backups/
```

## Kompletter Workflow - Schritt für Schritt

```bash
# === AUF LOKALEM RECHNER ===

# 1. Ins Verzeichnis wechseln
cd "E:\Dokumente\05_Skrift\Frontend_Backend_Konfigurator\Docker Backend"

# 2. Zum Server kopieren
rsync -avz --exclude='node_modules' --exclude='output' --exclude='cache' ./ root@SERVER:/opt/skrift-backend/


# === AUF DEM SERVER (per SSH) ===

# 3. Verbinden
ssh root@SERVER

# 4. Setup
cd /opt/skrift-backend
cat > .env << 'EOF'
SCRIPTALIZER_LICENSE_KEY=f9918b40-d11c-11f0-b558-0800200c9a66
SCRIPTALIZER_ERR_FREQUENCY=0
BATCH_SIZE=30
NODE_ENV=production
EOF

mkdir -p /var/skrift-output
docker-compose up -d --build

# 5. Testen
curl http://localhost:4000/health


# === IN NGINX PROXY MANAGER (Browser) ===

# 6. Proxy Host erstellen
# Domain: backend.deine-domain.de
# Forward to: skrift-backend:4000
# SSL: Let's Encrypt aktivieren


# === FERTIG! ===

# Von überall testen:
curl https://backend.deine-domain.de/health
```