# 🐳 Docker Deployment Anleitung

## Voraussetzungen

- Docker installiert (`docker --version`)
- Docker Compose installiert (`docker-compose --version`)
- Min. 2 GB freier RAM
- Min. 5 GB freier Speicherplatz

## 🚀 Schnellstart

### Option 1: Mit Deploy-Script (Empfohlen)

```bash
./deploy.sh
```

Folgen Sie den Anweisungen im interaktiven Menü.

### Option 2: Manuelle Commands

**Alles bauen und starten:**
```bash
docker-compose up -d --build
```

**Nur starten (bereits gebaut):**
```bash
docker-compose up -d
```

**Stoppen:**
```bash
docker-compose down
```

**Logs anzeigen:**
```bash
docker-compose logs -f
```

## 📦 Was wird deployed?

### 1. Flutter Web App Container
- **Image:** `flutter-tank-web:latest`
- **Port:** 8080 (Host) → 80 (Container)
- **URL:** `http://localhost:8080`
- **Technologie:** Flutter Web + Nginx

### 2. Proxy Server Container (Optional)
- **Image:** `ptv-proxy:latest`
- **Port:** 3000 (Host) → 3000 (Container)
- **URL:** `http://localhost:3000`
- **Technologie:** Node.js

## 🏗️ Build-Prozess

Der Build läuft in 2 Phasen:

**Phase 1: Flutter Build (Multi-Stage)**
1. Ubuntu base image
2. Flutter SDK installieren
3. Dependencies installieren (`flutter pub get`)
4. Web App bauen (`flutter build web`)

**Phase 2: Production (Nginx)**
1. Alpine Nginx image
2. Gebaute App kopieren
3. Nginx konfigurieren
4. Port 80 exponieren

**Geschätzte Build-Zeit:** 5-10 Minuten (beim ersten Mal)

## 🌐 Auf Server deployen

### 1. Server vorbereiten

**SSH zum Server:**
```bash
ssh user@your-server.com
```

**Docker installieren (falls nicht vorhanden):**
```bash
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
```

**Docker Compose installieren:**
```bash
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
```

### 2. Code auf Server übertragen

**Option A: Git Clone**
```bash
git clone https://github.com/your-repo/flutter_tank_web_app.git
cd flutter_tank_web_app
```

**Option B: SCP/Rsync**
```bash
# Von lokalem Rechner aus
rsync -avz --exclude 'build' --exclude '.dart_tool' \
  /home/digitalman/Development/flutter_tank_web_app/ \
  user@your-server.com:/opt/flutter-tank-app/
```

### 3. Environment anpassen

Bearbeiten Sie `lib/config/environment.dart`:
```dart
static const bool useLocalProxy = false;  // Für Produktion
```

### 4. Deployen

```bash
cd /opt/flutter-tank-app
./deploy.sh
# Wählen Sie Option 3: "Alles bauen und starten"
```

### 5. Mit Domain verbinden (Optional)

**Nginx Reverse Proxy konfigurieren:**
```nginx
# /etc/nginx/sites-available/tank.yourdomain.com
server {
    listen 80;
    server_name tank.yourdomain.com;

    location / {
        proxy_pass http://localhost:8080;
        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;
    }
}
```

**Aktivieren:**
```bash
sudo ln -s /etc/nginx/sites-available/tank.yourdomain.com /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

**SSL mit Let's Encrypt:**
```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d tank.yourdomain.com
```

## 🔧 Konfiguration

### Ports ändern

In `docker-compose.yml`:
```yaml
ports:
  - "8080:80"  # Ändern Sie 8080 auf gewünschten Port
```

### Umgebungsvariablen

Erstellen Sie `.env` Datei:
```env
# App Settings
APP_PORT=8080
PROXY_PORT=3000

# Domain (für Traefik)
DOMAIN=tank.yourdomain.com
```

### Mit Traefik (Reverse Proxy)

Die `docker-compose.yml` enthält bereits Traefik Labels.

**Traefik setup:**
```yaml
# docker-compose.traefik.yml
version: '3.8'
services:
  traefik:
    image: traefik:v2.10
    command:
      - "--providers.docker=true"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.letsencrypt.acme.email=your@email.com"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "./letsencrypt:/letsencrypt"
```

## 📊 Monitoring

### Container Status prüfen
```bash
docker-compose ps
```

### Logs anschauen
```bash
# Alle Services
docker-compose logs -f

# Nur Web App
docker-compose logs -f flutter-tank-web

# Nur Proxy
docker-compose logs -f ptv-proxy
```

### Resource Usage
```bash
docker stats
```

### Health Check
```bash
# Web App
curl http://localhost:8080/health

# Proxy
curl http://localhost:3000/health
```

## 🔄 Updates deployen

```bash
# Code aktualisieren
git pull

# Neu bauen und starten
docker-compose up -d --build

# Alte Images aufräumen
docker image prune -f
```

## 🛠️ Troubleshooting

### Container startet nicht
```bash
# Logs prüfen
docker-compose logs flutter-tank-web

# Container Status
docker-compose ps

# Neu starten
docker-compose restart flutter-tank-web
```

### Port bereits belegt
```bash
# Prozess auf Port finden
sudo lsof -i :8080

# Port in docker-compose.yml ändern
```

### Out of Memory
```bash
# Docker Memory Limit erhöhen
# In docker-compose.yml unter service:
deploy:
  resources:
    limits:
      memory: 2G
```

### Build schlägt fehl
```bash
# Docker Cache leeren
docker builder prune -a

# Komplett neu bauen
docker-compose build --no-cache
```

## 📦 Backup & Restore

### Volumes sichern
```bash
# Data Volume backup
docker run --rm -v flutter-tank-data:/data -v $(pwd):/backup alpine tar czf /backup/data-backup.tar.gz -C /data .
```

### Image speichern
```bash
# Image exportieren
docker save flutter-tank-web:latest | gzip > flutter-tank-web.tar.gz

# Image importieren
docker load < flutter-tank-web.tar.gz
```

## 🔒 Sicherheit

### Best Practices

1. **Nicht als Root laufen** (bereits in Proxy-Dockerfile implementiert)
2. **Security Headers** (bereits in nginx.conf)
3. **Firewall konfigurieren:**
```bash
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
```

4. **Regular Updates:**
```bash
# Base images updaten
docker-compose pull
docker-compose up -d
```

## 🎯 Performance Optimierung

### Nginx Caching
Bereits in `nginx.conf` konfiguriert:
- Static assets: 1 Jahr Cache
- Gzip Kompression aktiv

### Docker Image Size
```bash
# Image Größe prüfen
docker images flutter-tank-web

# Multi-stage build reduziert Größe bereits deutlich
```

## 📝 Checkliste Produktion

- [ ] `useLocalProxy = false` in environment.dart
- [ ] Domain konfiguriert
- [ ] SSL Zertifikat installiert
- [ ] Firewall konfiguriert
- [ ] Backup-Strategie definiert
- [ ] Monitoring eingerichtet
- [ ] Logs rotieren konfiguriert
- [ ] Update-Prozess dokumentiert

## 🆘 Support

Bei Problemen:
1. Logs prüfen: `docker-compose logs`
2. Container Status: `docker-compose ps`
3. Health Checks: `curl http://localhost:8080/health`
4. Docker System: `docker system df`