Voraussetzungen

Teamspeak 6 Server per Docker Compose installieren – Schritt für Schritt

Im Kern besteht die Installation aus fünf Schritten: Ports freigeben, Ordner anlegen, docker-compose.yml speichern, starten, Admin-Key aus Logs übernehmen.

1. Ports freigeben

Du hostest auf deinem Server daheim? Dann gehe in deinen Router und öffne für deinen Server folgende Ports:

• UDP 9987 für Voice
• TCP 30033 für den File Transfer
• Optional: TCP 10080 für Web Query (Nur wenn benötigt. Wenn du nicht weißt was das ist, dann skippe diesen Port.).

2. Ordner anlegen

mkdir ~/teamspeak6-server
cd ~/teamspeak6-server

3. Docker Compose Datei

Erstelle im Ordner eine Datei docker-compose.yml und kopiere Folgendes hinein. Speichern danach nicht vergessen.

services:
  teamspeak:
    image: teamspeaksystems/teamspeak6-server:latest
    container_name: teamspeak6-server
    restart: unless-stopped
    ports:
      - "9987:9987/udp"     # Voice
      - "30033:30033/tcp"   # File Transfer
      # - "10080:10080/tcp" # Web Query: optional, falls benötigt
    environment:
      - TSSERVER_LICENSE_ACCEPTED=accept
    volumes:
      - teamspeak6-data:/var/tsserver

volumes:
  teamspeak6-data:
    name: teamspeak6-data

Bei Bedarf findest du weitere Infos auch auf Github im offiziellen Teamspeak Bereich.

4. Container starten

Nun kannst den Server schon starten.

docker compose up -d

Überprüfung & Betrieb

Container-Status prüfen

docker compose ps

Der Service (`teamspeak6-server`) sollte im Zustand `running` sein.

Sicherheit & Updates

Neben deinem Linux-Server, solltest du auch immer wieder den Teamspeak 6 Server aktualisieren:

1. docker compose pull
2. docker compose up -d

Behalte im Hinterkopf, dass TS6 Beta ist und neue Versionen Features ändern oder instabil sein können

Persistenz & Backup

Deine Daten liegen im Named Volume „teamspeak6-data“.
Wenn dir die Daten auf dem Server und die Konfig egal sind, dann kannst du dir das sparen. Wenn nicht, dann ist es zu empfehlen das Volume regelmäßig zu sichern (z. B. innerhalb deines bestehendem Backup-Konzept).

Fazit

Mit einem eigenen TS6-Setup behältst du die Kontrolle über Voice, Erreichbarkeit und Updates – ohne dich an Discord-Accounts, Serverregeln oder Plattform-Policies binden zu müssen. Gleichzeitig ist TeamSpeak 6 für Umsteiger interessant, weil Screen-Sharing/Streaming im TS6-Client per Peer-to-Peer möglich ist, der Stream also nicht zwingend über deinen Server laufen muss.

Wenn du die Voraussetzungen erfüllst (fixe IPv4 bzw. stabile Erreichbarkeit und offene Ports), kannst du dafür ganz entspannt einen Heimserver oder sogar einen Raspberry Pi nutzen; alternativ funktioniert ein günstiger VPS genauso gut.

Kopiere jetzt die „docker-compose.yml“, starte den Container und poste in die Kommentare!

Weitere Anleitungen von mir findest du hier.

Konten verknüpfen

1. Öffne die iGPSPORT App.
2. Wechsle in den Reiter „My“.
3. Tippe auf „Link Other Apps“, um Komoot, TrainingPeaks oder Strava zu verbinden.
4. Nach erfolgreicher Verbindung findest du unter „My Roadbook“ die Option, Routen zu importieren.
5. Tippe auf das Plus-Symbol (+) und wähle „Import Third-Party Roadbook“ aus.

GPX-Datei importieren

1. Öffne in der Komoot App oder einem anderen Routenplaner die gewünschte Route.
2. Lade die GPX-Datei herunter.
3. Auf iOS kann die Datei meist direkt in die iGPSPORT App „geteilt“ werden.
   
4. Unter Android findest du die Datei im Dateimanager und öffnest sie mit der iGPSPORT App.
   
5. Alternativ: Öffne in der iGPSPORT App den Bereich „My“ → „My Roadbook“ → Plus-Symbol → „Import Roadbook“ und wähle die Datei manuell aus.

Route in iGPSPORT importieren: Fazit

Warum nutze ich Docker Compose?

• Alles in einer Datei: Klar strukturierte Konfiguration aller Services
• Einfache Wartung: Updates und Neustarts leicht durchführbar
• Isolation: Immich läuft in eigenen Containern, ohne dein Hostsystem zu beeinflussen
• GPU-Support leicht integrierbar: Unterschiedliche Grafikbeschleuniger können durch kleine Änderungen in der Compose-Datei eingebunden werden

Voraussetzungen

• Einen Linux- oder Windows-Server mit installiertem Docker und Docker Compose
• Idealerweise mindestens 4 GB RAM und zwei CPU Kerne
• Grafikkarte mit GPU-Unterstützung und entsprechendem Treiber:
  • Intel GPUs: OpenVINO unterstützt integrierte Intel-Grafik
  • AMD GPUs: ROCm für AMD-Grafikkarten (integriert oder diskret). AMD Grafikkarten aktuell nur experimentell unterstützt!
  • NVIDIA GPUs: CUDA-sowie NVIDIA Container Toolkit installiert
• Lese- und Schreibrechte mind. im Speicherort der Docker-Container.
• Grundkenntnisse: Linux-Befehle und Docker-Grundlagen von Vorteil!

Immich Docker Compose Setup – Schritt für Schritt

1. Ordner anlegen

mkdir ~/immich
cd ~/immich

2. Compose- und Environment-Dateien herunterladen

Lade idealerweise die aktuellen Dateien von Immich herunter, da diese immer auf dem aktuellsten Stand sein sollten. Anpassungen kannst du danach noch vornehmen, um unter anderem die GPU Unterstützung zu aktivieren:

wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env

3. `.env`-Datei anpassen

• Passwörter, User und Namen einstellen
• Bei Bedarf: Zeitzone (`TZ`) setzen und Speicherorte ändern (normalerweise keine Anpassungen erforderlich)

immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:${IMMICH_VERSION:-release}
    volumes:
      # Optional für externen Speicher
      - /mnt/shares/EXTERNER_ORDNER/:/usr/src/app/EXTERN
[...]

5. GPU Unterstützung aktivieren

Nun kann optional die GPU Unterstützung in der docker-compose.yml Datei konfiguriert werden. Anbei die Beispiele für integrierte Intel-GPUs und für Nvidia Grafikkarten. Es werden auch andere – teilweise experimentell – unterstützt. Prüfe hier idealerweise die offizielle Dokumentation.

immich-machine-learning:
    container_name: immich_machine_learning
    # Image spezifisch für integrierte Intel GPUs
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-openvino
    # Device übergeben, speziell für integrierte Intel (OpenVINO) und AMD (ROCm) GPUs
    devices:
      - /dev/dri:/dev/dri
    # AMD ist aktuell experimentell, bitte aktuelle Doku checken (auch für andere GPUs):
    # https://immich.app/docs/features/ml-hardware-acceleration/ 

    # Für NVIDIA GPUs bitte folgenden Abschnitt nutzen und oben image und device entfernen
    # image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-cuda
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]
    # runtime: nvidia
    # devices:
    #   - /dev/nvidia0:/dev/nvidia0
    #   - /dev/nvidiactl:/dev/nvidiactl
    #   - /dev/nvidia-uvm:/dev/nvidia-uvm
    #   - /dev/nvidia-uvm-tools:/dev/nvidia-uvm-tools
[...]

6. Container starten

Starte alle Container mit:

docker compose up -d

Überprüfung & Erfolgskontrolle

Container-Status prüfen

docker compose ps

Alle Services (`immich_server`, `immich_machine_learning`, `redis`, `immich_postgres`) sollten im Zustand `running` sein.

Log-Ausgaben überwachen

Nutze `docker logs -f immich_machine_learning`, um zu überprüfen, ob GPU-Beschleunigung erkannt wird (z. B. „CUDAExecutionProvider“).

Web-Interface öffnen

Greife im Browser auf `http://<SERVER-IP>:2283` zu und melde schließe die Konfiguration im Browser ab. Teste Uploads und die Gesichtserkennung, um sicherzugehen, dass alles funktioniert.

Fazit

Mit Docker Compose und aktivierter GPU-Unterstützung betreibst du Immich einfach, effizient und skalierbar. So nutzt du die Vorteile von Hardwarebeschleunigung für schnellere KI-Aufgaben und schonst die CPU. Die übersichtliche Konfiguration erleichtert Updates und Anpassungen und ist ideal für technisch anspruchsvolle Selbsthoster.

Starte noch heute mit dem Immich Docker Compose Setup inklusive GPU-Support und sichere deine Fotos intelligent und performant auf deinem Server. Passe `.env` und Compose-Datei an deine Bedürfnisse an und profitiere von der Hardwarebeschleunigung!
Falls du auch WordPress mit HTTPS und Traefik installieren möchtest, schaue hier vorbei.

Warum Docker Compose Container per Skript aktualisieren?

Das manuelle Aktualisieren mehrerer Docker Compose Projekte ist nicht nur mühsam, sondern auch fehleranfällig. Ein Skript automatisiert diesen Prozess, sorgt für eine saubere Umgebung durch das Entfernen ungenutzter Ressourcen und reduziert den Wartungsaufwand erheblich. So bleibt mehr Zeit für anderes.

Voraussetzungen und Vorbereitung

Bevor du Docker Compose Container per Skript aktualisieren kannst, sollten folgende Voraussetzungen erfüllt sein:

• Docker und Docker Compose sind installiert.

• Die Pfade zu den Docker Compose Projektverzeichnissen sind bekannt.

• Grundkenntnisse im Umgang mit der Shell sind vorhanden.

• Das Skript wird an die eigenen Bedürfnisse angepasst und ausführbar gemacht.

Skript im Detail – Schritt für Schritt

1. `docker-compose-update.sh` erstellen

Das folgende Bash-Skript ermöglicht es, mehrere Docker Compose Projekte zentral zu aktualisieren. Es bietet eine Auswahl der Projekte, stoppt die laufenden Container, entfernt ungenutzte Ressourcen, lädt die neuesten Images und startet die Container neu.

#!/bin/bash
# Array der Docker-Compose-Projektverzeichnisse
DOCKER_COMPOSE_DIRS=(
    "/pfad/zu/projekt1" 🔴 Pfade anpassen
    "/pfad/zu/projekt2" 🔴 Pfade anpassen
    # usw.
)
# Funktion zur Anzeige der Projekte
display_projects() {
    echo "Verfügbare Docker-Compose-Projekte:"
    for i in "${!DOCKER_COMPOSE_DIRS[@]}"; do
        echo "$((i+1)). ${DOCKER_COMPOSE_DIRS[i]}"
    done
}
# Überprüfen, ob Projekte gefunden wurden
if [ ${#DOCKER_COMPOSE_DIRS[@]} -eq 0 ]; then
    echo "Keine Docker-Compose-Projekte im Verzeichnis gefunden."
    exit 1
fi
# Projekte anzeigen
display_projects
# Auswahlaufforderung für das Projekt
while true; do
    read -p "Gib die Nummer des Projekts ein, das du aktualisieren möchtest (oder 'q' zum Beenden): " choice
    if [[ "$choice" == "q" ]]; then
        echo "Beende..."
        exit 0
    fi
    if [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -ge 1 ] && [ "$choice" -le ${#DOCKER_COMPOSE_DIRS[@]} ]; then
        project_index=$((choice-1))
        selected_project="${DOCKER_COMPOSE_DIRS[project_index]}"
        echo "Aktualisiere Docker-Compose-Projekt: $selected_project"
        cd "$selected_project" || exit
        echo "1. Stoppe aktuelle Services..."
        docker compose down
        echo "2. Entferne ungenutzte Ressourcen..."
        docker system prune -af --volumes
        echo "3. Lade neueste Images..."
        docker compose pull
        echo "4. Starte Services neu..."
        docker compose up -d
        echo "Aktualisierung abgeschlossen für $selected_project"
        exit 0
    else
        echo "Ungültige Auswahl. Bitte gib eine gültige Nummer oder 'q' ein."
    fi
done

2. Anpassungen vornehmen

Im Skript befindet sich ein Array mit den Pfaden zu deinen Docker Compose Projekten. Ersetze alle 🔴 markierten Stellen. Hier kommt der Pfad deines Ordners rein, in dem sich die Docker Compose Datei befinden.

DOCKER_COMPOSE_DIRS=(
  "/pfad/zu/projekt1"
  "/pfad/zu/projekt2"
  # usw.
)

Speichere das Skript aktualisierte Skript und mache es mit folgendem Befehl ausführbar:

chmod 755 docker-compose-update.sh

3. Skript ausführen und Container aktualisieren

Starte das Skript mit:

./docker-compose-update.sh

Du erhältst eine Auswahl aller Projekte. Nach Auswahl wird das gewünschte Docker Compose Projekt gestoppt, ungenutzte Ressourcen werden entfernt, die neuesten Images geladen und die Container neu gestartet. So kannst du alle Docker Compose Container per Skript aktualisieren – schnell und zuverlässig.

Fazit

Das Aktualisieren von Docker Compose Containern per Skript ist eine effiziente und zeitsparende Methode, um mehrere Projekte zuverlässig zu verwalten. Mit wenigen Anpassungen und Befehlen lässt sich die Wartung automatisieren und der Administrationsaufwand deutlich reduzieren.

Probiere das Skript aus und optimiere deine Docker Compose Verwaltung noch heute! Teile deine Erfahrungen und Fragen gerne in den Kommentaren.

Warum nutze ich Docker Compose?

• All-in-One-Konfiguration: Beschreibe alle notwendigen Dienste (WordPress, Certbot, Reverse Proxy) in einer einzigen `docker-compose.yml`-Datei.
• Isolation: Keine Abhängigkeiten zu deinem Server – alles läuft in einem Container.
• Automatisierte HTTPS-Zertifikate: Traefik kümmern sich um SSL/TLS, ohne manuelles Eingreifen.

Es gibt natürlich auch andere Möglichkeiten. Für mich hat sich Docker Compose aber bewährt.

Voraussetzungen

• Server:
  • Öffentliche IPv4-Adresse
  • SSH-Zugriff
  • Docker und Docker Compose installiert (Anleitung)
• Domain: Bereits konfigurierte Domain mit korrekter A/AAAA-Record-Zuordnung.
• Grundkenntnisse: Linux-Befehle, Docker-Grundlagen von Vorteil!

WordPress Docker Compose Setup – Schritt für Schritt

1. `docker-compose.yml` erstellen

Basierend auf meinen bisherigen Erfahrungen und den Herausforderungen, die mir begegnet sind, habe ich die Docker Compose Datei kontinuierlich optimiert und verbessert. Mittlerweile bin ich zufrieden.
Erstelle eine Datei `docker-compose.yml` mit folgendem Inhalt, idealerweise in einem WordPress Ordner:

services:
  traefik:
    image: traefik:latest
    restart: unless-stopped
    container_name: traefik
    command:
      - '--entryPoints.web.address=:80'
      - '--entryPoints.websecure.address=:443'
      - '--providers.docker=true'
      - '--certificatesResolvers.myresolver.acme.httpChallenge=true'
      - '--certificatesResolvers.myresolver.acme.httpChallenge.entryPoint=web'
      - '--certificatesResolvers.myresolver.acme.email=DEINE_EMAIL@deine-domain.de' # 🔴 Mail anpassen
      - '--certificatesResolvers.myresolver.acme.storage=/letsencrypt/acme.json'
      - '--log.level=DEBUG'
      - '--accesslog=true'
      - '--accesslog.fields.defaultmode=keep'
      - '--accesslog.fields.names.ClientAddr=keep'
      - '--accesslog.fields.names.RequestHost=keep'
      - '--accesslog.fields.names.RequestPath=keep'
      - '--accesslog.fields.names.RouterName=keep'
      - '--accesslog.fields.names.ServiceName=keep'
      - '--accesslog.fields.names.EntryPoint=keep'
    ports:
      - '80:80'
      - '443:443'
      - '8080:8080'
    volumes:
      - '/var/run/docker.sock:/var/run/docker.sock:ro'
      - './letsencrypt:/letsencrypt'
  wordpress:
    image: wordpress:latest
    restart: unless-stopped
    depends_on:
      - db
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: password # 🔴 Passwort anpassen
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - './wp_data:/var/www/html'
    labels:
      # Allgemein
      - 'traefik.enable=true'
      - 'traefik.http.routers.wordpress.rule=Host(`deine-domain.de`) || Host(`www.deine-domain.de`)' # 🔴 Domains anpassen
      # HTTPS aktivieren
      - 'traefik.http.routers.wordpress.entrypoints=websecure'
      - 'traefik.http.routers.wordpress.tls.certresolver=myresolver'
      # HTTP to HTTPS
      - 'traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https'
      - 'traefik.http.routers.wordpress.middlewares=redirect-to-https@docker'
      - 'traefik.http.routers.wordpress-http.rule=Host(`deine-domain.de`) || Host(`www.deine-domain.de`)' # 🔴 Domains anpassen
      - 'traefik.http.routers.wordpress-http.entrypoints=web'
      # HSTS Header
      - 'traefik.http.middlewares.hsts.headers.stsSeconds=31536000'
      - "traefik.http.middlewares.hsts.headers.stsIncludeSubdomains=true"
      - "traefik.http.middlewares.hsts.headers.stsPreload=true"
      - "traefik.http.routers.wordpress.middlewares=hsts@docker"
  db:
    image: mariadb:10.6.4-focal
    restart: unless-stopped
    volumes:
      - './db_data:/var/lib/mysql'
    environment:
      MYSQL_ROOT_PASSWORD: password # 🔴 Passwort anpassen
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: password # 🔴 Passwort anpassen

2. Anpassungen vornehmen

• Ersetze alle 🔴 markierten Stellen:
  • `DEINE_EMAIL@deine-domain.de` → Deine E-Mail für Let’s Encrypt-Benachrichtigungen.
  • `deine-domain.de` → Deine registrierte Domain.
  • `password` → Starke Passwörter.

3. Docker-Container starten

Führe im Verzeichnis der `docker-compose.yml` folgenden Befehl aus:

docker compose up -d

Überprüfung & Erfolgskontrolle

1. HTTPS prüfen: Öffne `https://deine-domain.de` – es sollte eine sichere Verbindung (🔒) und die WordPress-Installationsseite erscheinen.
2. Container-Status:
   docker compose ps
   Alle Services sollten `running` anzeigen.
   

Fazit

Mit dieser Docker-Compose-Lösung hast du eine sichere und leicht wartbare WordPress-Instanz mit automatischer HTTPS-Verschlüsselung. Das Setup ist ideal für alle, die maximale Kontrolle über ihre Infrastruktur wünschen – ohne komplexe Server-Konfiguration.

Viel Erfolg beim Umsetzen! Hast du Fragen oder Anregungen? Hinterlasse mir gerne einen Kommentar. Möchtest du den Container einfach aktualisieren? Dann findest du hier eine weitere Anleitung.