# Setup-Anleitung — Debian Server

## Voraussetzungen

- Debian 11 / 12
- Root oder sudo-Zugriff
- Dein Hetzner Reverse Proxy zeigt auf diese Maschine
- Port 8888 im Reverse Proxy weitergeleitet

---

## 1. Docker installieren (falls noch nicht vorhanden)

```bash
# Alte Versionen entfernen
sudo apt remove docker docker-engine docker.io containerd runc 2>/dev/null

# Abhängigkeiten
sudo apt update
sudo apt install -y ca-certificates curl gnupg

# Docker GPG-Key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker installieren
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Deinen User zur docker-Gruppe hinzufügen (kein sudo nötig)
sudo usermod -aG docker $USER
newgrp docker

# Test
docker --version
docker compose version
```

---

## 2. Projektdateien auf den Server bringen

```bash
# Auf deinem lokalen Rechner — Dateien hochladen
scp -r kennzeichen-website/ user@dein-server:/opt/kennzeichen-website

# Oder: Git-Repo anlegen und pushen/pullen
# Dann auf dem Server:
cd /opt/kennzeichen-website
```

Alternativ direkt auf dem Server mit nano/vim die Dateien anlegen
(der Ordner existiert ja schon).

---

## 3. Konfiguration anpassen

```bash
cd /opt/kennzeichen-website

# domain in docker-compose.yml setzen
nano docker-compose.yml
```

In der `docker-compose.yml` die zwei Umgebungsvariablen anpassen:
```yaml
environment:
  - NEXT_PUBLIC_PB_URL=https://deine-echte-domain.de/api   # ← anpassen
  - PB_INTERNAL_URL=http://pocketbase:8090                 # ← so lassen
```

---

## 4. PocketBase Admin-UI einmalig direkt exponieren

Beim allerersten Start muss der Admin-Account angelegt werden.
Dafür kurz PocketBase direkt zugänglich machen:

```bash
# In docker-compose.yml temporär unter pocketbase: hinzufügen:
#   ports:
#     - "8090:8090"
```

Dann starten:
```bash
docker compose up -d pocketbase
```

Im Browser aufrufen: `http://<server-ip>:8090/_/`
→ Admin-Account anlegen (E-Mail + Passwort merken!)

Danach den `ports:`-Block wieder aus der docker-compose.yml entfernen.

---

## 5. Alles starten

```bash
cd /opt/kennzeichen-website

# Beim ersten Mal: Images bauen (dauert 2–5 Min)
docker compose build

# Starten
docker compose up -d

# Status prüfen
docker compose ps

# Logs ansehen
docker compose logs -f nextjs
docker compose logs -f pocketbase
```

Die Website ist jetzt unter Port 8888 erreichbar.

---

## 6. Daten importieren

```bash
# Python-Abhängigkeiten
pip3 install requests

# plates-Repo klonen (falls noch nicht vorhanden)
git clone https://git.denode.eu/denode/plates /opt/plates

# data.db auf den Server bringen
scp data.db user@dein-server:/opt/

# Import starten
cd /opt/kennzeichen-website
python3 scripts/import.py \
  --pb-url http://localhost:8090 \
  --pb-email deine@email.de \
  --pb-password deinpasswort \
  --repo-path /opt/plates \
  --db-path /opt/data.db
```

PocketBase ist beim Import direkt über localhost:8090 erreichbar
(kein Port nach außen nötig, nur von der Servermaschine selbst).

---

## 7. Reverse Proxy konfigurieren

In deinem Hetzner-Reverse-Proxy die Domain auf `<wireguard-ip>:8888` zeigen lassen.

Nginx Beispiel (auf dem Proxy-Server):
```nginx
server {
    listen 443 ssl;
    server_name deine-domain.de;

    # SSL-Zertifikat (z.B. Let's Encrypt)
    ssl_certificate     /etc/letsencrypt/live/deine-domain.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/deine-domain.de/privkey.pem;

    # Next.js
    location / {
        proxy_pass http://<wireguard-ip>:8888;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # PocketBase API (wird von Next.js intern genutzt,
    # aber für den Browser-SDK zugänglich machen)
    location /api/ {
        proxy_pass http://<wireguard-ip>:8888/api/;
        proxy_set_header Host $host;
    }
}
```

---

## 8. Auto-Update bei Git-Änderungen (optional)

```bash
# Cron-Job: täglich Daten aus plates-Repo neu importieren
crontab -e
```

```cron
# Jeden Tag um 03:00 Uhr
0 3 * * * cd /opt/plates && git pull && \
  python3 /opt/kennzeichen-website/scripts/import.py \
  --pb-url http://localhost:8090 \
  --pb-email deine@email.de \
  --pb-password deinpasswort \
  --repo-path /opt/plates \
  --db-path /opt/data.db \
  --skip-schema \
  >> /var/log/kennzeichen-import.log 2>&1
```

---

## Nützliche Befehle

```bash
# Neustart nach Code-Änderungen
docker compose build nextjs && docker compose up -d nextjs

# PocketBase-Daten sichern
docker cp kennzeichen-website_pb_data_1:/pb/pb_data ./backup-$(date +%Y%m%d)

# Logs verfolgen
docker compose logs -f

# Alles stoppen
docker compose down
```

---

## Projektstruktur (Endzustand)

```
/opt/kennzeichen-website/
├── docker-compose.yml
├── README.md
├── SCHEMA.md
├── docker/
│   └── pocketbase/
│       └── Dockerfile
├── frontend/
│   ├── Dockerfile
│   ├── package.json
│   ├── next.config.js
│   ├── tailwind.config.ts
│   ├── tsconfig.json
│   ├── app/
│   │   ├── layout.tsx        # Root Layout + Navigation
│   │   ├── page.tsx          # Startseite
│   │   ├── globals.css       # Design-System
│   │   ├── kennzeichen/
│   │   │   ├── page.tsx      # Datenbank mit Suche + Filter
│   │   │   └── KennzeichenFilter.tsx
│   │   ├── diplomatenkennzeichen/
│   │   │   └── page.tsx
│   │   ├── sammlung/
│   │   │   └── page.tsx      # Persönlicher Fortschritt
│   │   └── blog/
│   │       ├── page.tsx      # Blog-Übersicht
│   │       └── [slug]/
│   │           └── page.tsx  # Blog-Post
│   ├── components/
│   │   └── ui/
│   │       └── Nav.tsx
│   └── lib/
│       └── pb.ts             # PocketBase Client + Typen
└── scripts/
    ├── import.py
    └── validate.py
```