# Minecraft Server Generator für Coolify

Web-basierter Generator für Minecraft Server mit Velocity-Netzwerk Integration und SFTP-Zugriff. Direkt in Coolify deploybar!

## 🎯 Features

- ✅ **Web-Interface** - Benutzerfreundliche Oberfläche zur Server-Erstellung
- ✅ **Automatische Generierung** - Download fertiger Docker Compose Konfigurationen
- ✅ **Velocity Integration** - Perfekt für Proxy-Netzwerke konfiguriert
- ✅ **SFTP Zugriff** - Einfache Plugin-Verwaltung über FileZilla/WinSCP
- ✅ **Persistent Volumes** - Daten bleiben bei Updates erhalten
- ✅ **Docker Compose Ready** - Direkt in Coolify nutzbar
- ✅ **Health Checks** - Automatische Überwachung
- ✅ **Performance Optimiert** - Aikar Flags und Best Practices

## 🚀 Schnellstart

### 1. Generator in Coolify deployen

#### Auf Gitea hochladen:
```bash
# Repository initialisieren
git init
git add .
git commit -m "Initial commit: Minecraft Server Generator"

# Auf Gitea pushen
git remote add origin https://dein-gitea-server/user/minecraft-generator.git
git push -u origin main
```

#### In Coolify importieren:
1. Gehe zu Coolify Dashboard
2. **New Resource** → **Docker Compose**
3. Verbinde dein Gitea Repository
4. Branch: `main`
5. **Deploy!**

Der Generator läuft dann auf Port 3000 und ist über deine Coolify-Domain erreichbar.

### 2. Minecraft Server erstellen

1. Öffne den Generator in deinem Browser
2. Fülle das Formular aus:
   - Server Name (z.B. lobby, survival, minigames)
   - Minecraft Version
   - Server Software (Paper empfohlen)
   - RAM Einstellungen
   - Velocity Secret
   - SFTP Zugangsdaten
3. Klicke auf **"Server-Dateien generieren"**
4. ZIP-Datei wird automatisch heruntergeladen

### 3. Server deployen

```bash
# ZIP entpacken
unzip minecraft-lobby.zip

# Neues Git Repo erstellen
cd minecraft-lobby
git init
git add .
git commit -m "Initial commit: Lobby Server"

# Auf Gitea pushen
git remote add origin https://dein-gitea-server/user/mc-lobby.git
git push -u origin main
```

Dann in Coolify:
1. **New Resource** → **Docker Compose**
2. Gitea Repository verbinden
3. **Deploy!**

## 📖 Voraussetzungen

- Coolify Installation
- Gitea oder anderer Git-Server
- Docker & Docker Compose (automatisch durch Coolify)

## 📁 Generierte Struktur

Nach dem Ausführen wird folgende Struktur erstellt:

```
[server-name]/
├── docker-compose.yml      # Docker Compose Konfiguration
├── .coolify.yml            # Coolify spezifische Config
├── config/                 # Server Konfiguration
│   ├── paper-global.yml    # Velocity Integration
│   ├── spigot.yml         
│   └── server.properties   
├── deploy.sh               # Deployment Script
├── README.md               # Server-spezifische Dokumentation
└── .gitignore
```

## 🌐 Velocity Netzwerk Setup

### 1. Backend Server (Lobby, Survival, etc.)

Jeder Backend-Server wird automatisch mit Velocity-Support konfiguriert:

```yaml
proxies:
  velocity:
    enabled: true
    online-mode: false
    secret: 'dein-secret'
```

### 2. Velocity Proxy Konfiguration

Füge deine Server zur `velocity.toml` hinzu:

```toml
[servers]
  lobby = "server1.coolify:25565"
  survival = "server2.coolify:25566"
  minigames = "server3.coolify:25567"

try = [
  "lobby"
]

[forced-hosts]
  "lobby.deine-domain.de" = ["lobby"]
  "survival.deine-domain.de" = ["survival"]
  "minigames.deine-domain.de" = ["minigames"]

[player-info-forwarding]
  mode = "modern"
  secret = "dein-gemeinsames-secret"
```

## 📦 SFTP Plugin-Verwaltung

Jeder Server bekommt einen eigenen SFTP-Container für einfache Plugin-Verwaltung.

### Verbindung mit FileZilla

1. Öffne FileZilla
2. **Host:** `sftp://dein-server.de`
3. **Port:** Der konfigurierte SFTP Port (z.B. 2222)
4. **Benutzer:** Dein SFTP Username
5. **Passwort:** Dein SFTP Passwort
6. Verbinden!

### Verbindung mit WinSCP

1. Öffne WinSCP
2. Neuer Session
   - Protokoll: SFTP
   - Host: dein-server.de
   - Port: SFTP Port
   - Benutzername & Passwort
3. Anmelden!

### Ordnerstruktur über SFTP

```
/home/[username]/
├── plugins/        # Hier Plugins hochladen (.jar Dateien)
├── config/         # Konfigurationsdateien
└── data/          # Weltdaten (nur lesend)
```

### Plugins installieren

1. Verbinde dich via SFTP
2. Navigiere zu `/plugins`
3. Lade deine `.jar` Dateien hoch
4. Starte Server neu in Coolify oder via SSH:
   ```bash
   docker-compose restart minecraft-[server-name]
   ```

## 🔧 Deployment in Coolify

### Option 1: Über Git Repository (Empfohlen)

```bash
# In deinem Server-Ordner
cd [server-name]

# Git initialisieren
git init
git add .
git commit -m "Initial commit: [server-name]"

# Zu deinem Repository pushen
git remote add origin https://github.com/dein-user/dein-repo.git
git push -u origin main
```

Dann in Coolify:
1. **New Resource** → **Docker Compose**
2. Git Repository verbinden
3. Branch auswählen (main)
4. Deploy!

### Option 2: Direkt auf Coolify Server

```bash
# Kopiere Ordner auf Coolify Server
scp -r [server-name] user@coolify-server:/pfad/

# SSH auf Server
ssh user@coolify-server

# Deploy
cd /pfad/[server-name]
./deploy.sh
```

## 🎮 Mehrere Server erstellen

Du kannst das Skript mehrmals ausführen für verschiedene Server:

```bash
# Lobby Server
./create-minecraft-server.sh
# Input: lobby, 1.21, Paper, 2GB-4GB, Port 25565, SFTP Port 2222

# Survival Server
./create-minecraft-server.sh
# Input: survival, 1.21, Paper, 4GB-8GB, Port 25566, SFTP Port 2223

# Minigames Server
./create-minecraft-server.sh
# Input: minigames, 1.20.4, Paper, 2GB-4GB, Port 25567, SFTP Port 2224
```

Jeder Server bekommt:
- Eigenen Docker Container
- Eigene Volumes (Daten persistent)
- Eigenen SFTP Zugang
- Eigenen Port

## 🛠️ Server Management

### Logs ansehen (in Coolify oder SSH)

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

# Nur Minecraft Server
docker-compose logs -f minecraft-[server-name]

# Nur SFTP Server
docker-compose logs -f sftp-[server-name]
```

### Server Console

```bash
# Interaktive Minecraft Console
docker exec -it mc-[server-name] rcon-cli

# Dann kannst du Commands ausführen:
> list
> op Username
> whitelist add Username
```

### Backup erstellen

```bash
# Erstelle Backup Ordner
mkdir -p backups

# Backup
docker run --rm \
  -v mc-[server-name]-data:/data \
  -v $(pwd)/backups:/backup \
  alpine tar czf /backup/backup-$(date +%Y%m%d-%H%M%S).tar.gz -C /data .
```

### Server neustarten

```bash
docker-compose restart minecraft-[server-name]
```

### Server stoppen

```bash
docker-compose down
```

### Server starten

```bash
docker-compose up -d
```

## 🔒 Sicherheit Best Practices

### 1. Firewall Konfiguration

Nur Velocity Proxy sollte sich zu Backend-Servern verbinden können:

```bash
# Auf Backend-Server (z.B. mit ufw)
sudo ufw allow from [VELOCITY-PROXY-IP] to any port 25565
sudo ufw deny 25565  # Blockiere von allen anderen
```

### 2. Sichere Secrets verwenden

```bash
# Generiere sichere Secrets
openssl rand -base64 32
```

Nutze diesen Output für `forwarding-secret`.

### 3. SFTP Passwörter ändern

Nach dem ersten Setup, ändere SFTP Passwörter in der `docker-compose.yml`:

```yaml
command: ${SFTP_USER}:neues-sicheres-passwort:1000:1000:plugins,config,data
```

### 4. Regelmäßige Updates

```bash
# Docker Images updaten
docker-compose pull
docker-compose up -d
```

## 📊 Performance Tipps

### 1. Aikar Flags (bereits aktiviert)

Die optimalen JVM Flags sind bereits gesetzt via `USE_AIKAR_FLAGS: "true"`.

### 2. View Distance anpassen

In `server.properties` oder als Environment Variable:

```yaml
VIEW_DISTANCE: 8  # Reduzieren bei Lag
SIMULATION_DISTANCE: 6
```

### 3. Paper Timings

Auf dem Server:
```
/timings on
# Warte 10-15 Minuten
/timings paste
```

Analysiere die URL um Lag-Quellen zu finden.

### 4. Chunk-Loading optimieren

In `paper-world-defaults.yml`:
```yaml
chunks:
  auto-save-interval: 6000  # 5 Minuten statt 1
```

## 🐛 Troubleshooting

### Problem: Server startet nicht

**Lösung:**
```bash
# Prüfe Logs
docker-compose logs minecraft-[server-name]

# Häufige Fehler:
# - Port bereits belegt → Ändere Port in docker-compose.yml
# - Zu wenig RAM → Erhöhe Memory Limits
# - EULA nicht akzeptiert → Sollte automatisch sein, prüfe EULA: "TRUE"
```

### Problem: Velocity Verbindung fehlgeschlagen

**Lösung:**
1. Prüfe ob Secret in Velocity und Paper identisch ist
2. Stelle sicher dass `online-mode=false` auf Backend-Server
3. Teste Netzwerk-Verbindung:
   ```bash
   # Auf Velocity Server
   telnet backend-server 25565
   ```

### Problem: SFTP Login funktioniert nicht

**Lösung:**
```bash
# Prüfe SFTP Container Status
docker-compose ps sftp-[server-name]

# Prüfe Logs
docker-compose logs sftp-[server-name]

# Teste Verbindung
sftp -P [SFTP-PORT] [USER]@[HOST]
```

### Problem: Plugins werden nicht geladen

**Lösung:**
1. Prüfe ob Plugin kompatibel mit Minecraft Version ist
2. Checke Server Logs nach Fehlern:
   ```bash
   docker-compose logs minecraft-[server-name] | grep ERROR
   ```
3. Stelle sicher dass `.jar` Dateien im richtigen Ordner sind
4. Restart nach Plugin-Installation:
   ```bash
   docker-compose restart minecraft-[server-name]
   ```

## 📚 Empfohlene Plugins

### Essentials
- **LuckPerms** - Permission Management
- **EssentialsX** - Core Commands
- **Vault** - Economy API

### Velocity Netzwerk
- **LiteBans** - Network-wide Bans
- **TAB** - Tablist & Scoreboard
- **AdvancedPortals** - Server Portale
- **ViaVersion** - Multi-Version Support

### Performance & Optimization
- **Chunky** - Pre-generate Chunks
- **FarmControl** - Optimize Farms
- **ClearLag** - Remove Entity Lag

### Fun & Features
- **Citizens** - NPCs
- **WorldEdit** - Building Tools
- **CoreProtect** - Rollback System
- **Geyser** - Bedrock Support (optional)

## 🔄 Update Prozess

### Server Software updaten

```bash
# In docker-compose.yml VERSION ändern
VERSION: "1.21.1"

# Neustart
docker-compose pull
docker-compose up -d
```

### Plugins updaten

1. Via SFTP zu `/plugins` verbinden
2. Alte `.jar` löschen
3. Neue `.jar` hochladen
4. Server neustarten

## 📞 Support & Community

- **Paper Docs:** https://docs.papermc.io/
- **Velocity Docs:** https://docs.papermc.io/velocity
- **Coolify Docs:** https://coolify.io/docs

## 📝 Changelog

### Version 1.0.0 (Initial Release)
- ✅ Automatische Server-Erstellung
- ✅ Velocity Integration
- ✅ SFTP Support
- ✅ Docker Compose Setup
- ✅ Coolify Kompatibilität
- ✅ Health Checks
- ✅ Persistent Volumes

## 🙏 Credits

Erstellt für einfaches Minecraft Server Management mit Coolify.

**Verwendete Docker Images:**
- `itzg/minecraft-server` - Minecraft Server
- `atmoz/sftp` - SFTP Server

---

**Made with ❤️ for the Minecraft Community**