# Backup-Automation für MBO-Tech-IT

Integriertes Backup-System basierend auf Netbox-Inventar, Kestra-Automation, Borg Backup und Hetzner S3.

## 📋 Architektur-Übersicht

```
┌─────────────────────────────────────────────────────────────┐
│ Kestra (kestra.mbo-tech-it.de)                         │
│ • Tägliche Abfrage von Netbox (TAG: backup=true)          │
│ • Trigger Ansible auf allen markierten Hosts              │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Ansible Playbook (install-borg-client.yaml)               │
│ • Install Borg, SSH-Keys, Backup-Scripts                  │
│ • Systemd Timer für regelmäßige Backups (03:00 Uhr)       │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Backup-Clients (alle gekennzeichneten Systeme)            │
│ • Borg Backup-Script läuft täglich um 03:00               │
│ • Docker Pre-Backup Hooks (MySQL, PostgreSQL, Volumes)    │
│ • SSH zu Backup-Server: backup@backup.mbo-tech-it.de │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Backup-Server (backup.mbo-tech-it.de)                 │
│ Struktur: /backup/repos/{hostname}/                        │
│ • Zentrale Borg-Repositories pro Host                      │
│ • SSH-Zugang nur für borg serve (restricted)              │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Rclone Sync (täglich 04:00)                                │
│ Struktur: s3://mbo-backups/production/repos/{hostname}/    │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Hetzner S3 Storage                                         │
│ Offsite-Backup mit Versionierung & Redundanz              │
└─────────────────────────────────────────────────────────────┘
```

## 🚀 Quick Start

### 1. Netbox vorbereiten

Füge das TAG `backup` mit Wert `true` zu allen Systemen hinzu, die gebackuped werden sollen:

```bash
# Via Netbox UI oder API:
curl -X POST https://netbox.mbo-tech-it.de/api/extras/tags/ \
  -H "Authorization: Token YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "backup",
    "slug": "backup",
    "description": "System sollte gebackuped werden"
  }'
```

### 2. Git-Repository clonen

```bash
git clone https://gitea.mbo-tech-it.de/jonny/backup-automation.git
cd backup-automation
```

### 3. Backup-Server vorbereiten

```bash
# SSH auf Backup-Server
ssh root@backup.mbo-tech-it.de

# Ansible Playbook ausführen
ansible-playbook -i localhost, \
  ansible/playbooks/configure-backup-server.yaml \
  -e "hetzner_s3_access_key=YOUR_KEY" \
  -e "hetzner_s3_secret_key=YOUR_SECRET"
```

### 4. Kestra-Workflow hochladen

```bash
# Workflow in Kestra hochladen
curl -X POST https://kestra.mbo-tech-it.de/api/v1/flows \
  -H "Content-Type: application/yaml" \
  -d @kestra/workflows/backup-provision.yaml
```

### 5. Secrets in Kestra setzen

```
Settings → Secrets:
- NETBOX_TOKEN: (dein Netbox API Token)
- NETBOX_URL: https://netbox.mbo-tech-it.de
```

---

## 📖 Dateien & Funktionen

| Datei | Beschreibung |
|-------|-------------|
| `kestra/workflows/backup-provision.yaml` | Hauptworkflow: Netbox→Ansible |
| `ansible/playbooks/install-borg-client.yaml` | Installation auf Clients |
| `ansible/playbooks/configure-backup-server.yaml` | Backup-Server Setup |
| `scripts/borg-backup.sh` | Backup-Ausführung pro Host |
| `scripts/pre-backup-docker.sh` | Docker-spezifische Dumps |
| `rclone-sync.service` | S3-Synchronisierung |

---

## 🔒 Security Considerations

1. **SSH-Keys**: Ed25519-Keys für Borg-Zugriff
   - Private Keys: `/root/.ssh/mbo-backup-key.ed25519` (auf Clients)
   - Public Keys: `authorized_keys` auf Backup-Server mit `restrict,command=...`

2. **Borg Encryption**: AES256-CTR mit Passphrases
   - Passphrase sollte in Ansible Vault gespeichert sein

3. **Netbox API Token**: Via Kestra Secrets (nicht im Git!)

4. **Hetzner S3 Credentials**: Via Ansible Vault oder Umgebungsvariablen

---

## 📊 Monitoring & Status

### Backup-Status anzeigen

```bash
# Auf jedem Client:
systemctl status mbo-backup.timer
systemctl list-timers mbo-backup.timer

# Logs:
journalctl -u mbo-backup -f
tail -f /var/log/mbo-backup/*.log
```

### Rclone Sync-Status

```bash
# Auf Backup-Server:
systemctl status mbo-rclone-sync.timer
journalctl -u mbo-rclone-sync -f

# Manuelle Sync:
sudo -u backup rclone sync --progress /backup/repos hetzner:mbo-backups/production/repos
```

### Borg Repository Status

```bash
ssh backup@backup.mbo-tech-it.de
borg list /backup/repos/SERVER_NAME
borg info /backup/repos/SERVER_NAME::(latest-backup)
```

---

## 🔄 Restore-Prozeduren

### Komplettes Restore eines Servers

```bash
# 1. SSH zum Server
ssh root@SERVER_NAME

# 2. Hole aktuelles Backup vom Backup-Server
borg extract --progress \
  backup@backup.mbo-tech-it.de:/backup/repos/SERVER_NAME::(latest) \
  /etc

# 3. Oder aus S3 (falls lokal nicht verfügbar)
rclone ls hetzner:mbo-backups/production/repos/SERVER_NAME/
```

### Einzelne Datei restoren

```bash
# Liste Backup-Archive
borg list backup@backup.mbo-tech-it.de:/backup/repos/SERVER_NAME

# Extrahiere einzelne Datei
borg extract \
  backup@backup.mbo-tech-it.de:/backup/repos/SERVER_NAME::archive-name \
  path/to/file
```

### Docker Volume restoren

```bash
# Auf Backup-Server:
ssh backup@backup.mbo-tech-it.de

# Finde den Export
ls -la /var/backups/docker/*/

# Entpacke und restore zum Container
docker run --rm \
  -v myvolume:/data \
  -v /var/backups/docker/DUMP:/backup \
  alpine tar xzf /backup/volume-myvolume.tar.gz -C /data
```

---

## 🐛 Troubleshooting

### SSH-Fehler beim Backup

```bash
# Test SSH-Connection:
ssh -i /root/.ssh/mbo-backup-key.ed25519 \
  backup@backup.mbo-tech-it.de "echo OK"

# SSH-Keys neu generieren (falls nötig):
ssh-keygen -t ed25519 -N '' -f /root/.ssh/mbo-backup-key.ed25519
```

### Borg Repository korrupt

```bash
# Backup-Server:
ssh backup@backup.mbo-tech-it.de
borg check -v /backup/repos/SERVER_NAME
borg repair /backup/repos/SERVER_NAME
```

### Rclone S3 Sync läuft nicht

```bash
# Teste Rclone Connection:
sudo -u backup rclone listremotes
sudo -u backup rclone ls hetzner:

# Überprüfe Config:
sudo -u backup rclone config show hetzner

# Debugging:
sudo -u backup rclone sync --progress --log-level DEBUG \
  /backup/repos hetzner:mbo-backups/production/repos
```

### Kestra Workflow fehlt

```bash
# Logs in Kestra:
Settings → Logs → backup-provision

# Manuelle Test:
curl -X GET https://kestra.mbo-tech-it.de/api/v1/namespaces/automation/flows
```

---

## 📈 Performance Tuning

### Borg-Kompression

```bash
# Schneller (weniger CPU): lz4
# Besser (mehr Dedupe): zstd
# Im Script anpassen: --compression zstd,10
```

### Rclone Sync Parallel

```bash
# In rclone-sync.service:
rclone sync --progress --transfers 4 --checkers 8 \
  /backup/repos hetzner:mbo-backups/production/repos
```

### Backup-Größe reduzieren

```bash
# Exclude-List in borg-backup.sh erweitern:
--exclude '*.log'
--exclude '.cache'
--exclude 'node_modules'
```

---

## 📝 Wartung & Cleanup

### Alte Backups prünen

Der borg prune läuft automatisch:
- Tägliche: 7 Tage
- Wöchentliche: 4 Wochen
- Monatliche: 12 Monate

Zu ändern in `borg-backup.sh`:

```bash
borg prune "$REPO_PATH" \
  --keep-daily=7 \
  --keep-weekly=4 \
  --keep-monthly=12
```

### Docker-Dumps aufräumen

```bash
# Manuell (normalerweise automatisch):
find /var/backups/docker -type d -mtime +7 -exec rm -rf {} \;
```

---

## 📞 Support & Fragen

- Kestra Docs: https://kestra.io/docs
- Borg Backup Docs: https://borgbackup.readthedocs.io
- Rclone S3: https://rclone.org/s3/
- Netbox API: https://netbox.mbo-tech-it.de/api/docs/

---

**Version**: 1.0  
**Letzte Aktualisierung**: 2026-09-09  
**Maintainer**: Jonny (MBO-Tech-IT)