Server-Projekte mit Portainer – Docker einfach verwalten

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernst du, wie du mit Portainer eigene Server-Projekte umsetzt:

Was ist Portainer? Die visuelle Docker-Verwaltung
Vorteile: Warum Portainer nutzen?
Installation: Docker + Portainer Setup
Docker Compose: Stacks in Portainer nutzen
10 Praxis-Projekte: Von WordPress bis Minecraft-Server
Best Practices: Sicherheit, Backup, Monitoring
FAQ: Häufige Fragen und Troubleshooting

1. Was ist Portainer?

Portainer – Docker einfach gemacht

Portainer ist eine leichtgewichtige, webbasierte Verwaltungsoberfläche für Docker, Docker Swarm, Kubernetes und Azure ACI. Es vereinfacht die Verwaltung von Containern, Images, Volumes, Netzwerken und Stacks durch eine intuitive grafische Oberfläche.

Statt komplexe Docker-Befehle in der Kommandozeile einzutippen, kannst du mit Portainer Container per Klick starten, stoppen, konfigurieren und überwachen. Besonders für Einsteiger ist Portainer der perfekte Einstieg in die Container-Welt.

Portainer gibt es in zwei Versionen: Community Edition (CE) – kostenlos und für die meisten Use Cases ausreichend – und Business Edition (BE) mit erweiterten Features für Unternehmen.

Warum Portainer nutzen?

Die wichtigsten Vorteile von Portainer auf einen Blick:

Intuitive GUI

Webbasierte Oberfläche statt Kommandozeile. Container per Klick starten, stoppen und konfigurieren.

App-Templates

Vorgefertigte Templates für beliebte Anwendungen wie WordPress, Nextcloud, Pi-hole und viele mehr.

Stack-Verwaltung

Docker Compose Stacks direkt im Browser bearbeiten und deployen – ideal für Multi-Container-Setups.

Live-Monitoring

Echtzeit-Statistiken zu CPU, RAM, Netzwerk und Logs direkt in der Oberfläche.

Multi-Host

Mehrere Docker-Hosts und Umgebungen von einer einzigen Portainer-Instanz aus verwalten.

Zugriffskontrolle

Benutzerverwaltung mit Rollen und Berechtigungen für Teams und Unternehmen.

2. Installation – Docker & Portainer

Bevor du Portainer nutzen kannst, musst du Docker auf deinem Server installieren. Hier die Schritte für Linux (Ubuntu/Debian):

Schritt-für-Schritt Installation

1

Docker installieren

Docker über das offizielle Repository installieren:

                    BASH
# System aktualisieren
sudo apt update && sudo apt upgrade -y

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

# Docker GPG-Key hinzufügen
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Docker Repository hinzufügen
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) 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
                

2

Docker-Daemon starten

Docker aktivieren und beim Systemstart automatisch starten:

                    BASH
sudo systemctl enable docker
sudo systemctl start docker

# Optional: Aktueller Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER
# Danach neu einloggen, damit die Gruppenänderung wirkt
                

3

Portainer CE installieren

Portainer als Docker-Container starten:

                    BASH
# Volume für Portainer-Daten erstellen
sudo docker volume create portainer_data

# Portainer CE Container starten
sudo docker run -d \
  -p 8000:8000 \
  -p 9443:9443 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest
                

4

Portainer im Browser öffnen

Portainer ist nun unter folgender URL erreichbar:

                    URL
https://DEINE-SERVER-IP:9443
                

Beim ersten Aufruf musst du einen Admin-Benutzer mit Passwort anlegen. Danach kannst du direkt loslegen!

Tipp: Firewall konfigurieren

Falls du eine Firewall (z.B. UFW) nutzt, musst du den Port 9443 freigeben:

                BASH
sudo ufw allow 9443/tcp
sudo ufw reload
            

3. Docker Compose & Stacks

Die meisten Server-Projekte bestehen aus mehreren Containern, die zusammenarbeiten (z.B. WordPress + MySQL). Docker Compose ermöglicht es, solche Setups in einer einzigen YAML-Datei zu definieren.

Was ist ein Stack?

Ein Stack ist eine Gruppe von Containern, die zusammen definiert und deployed werden. In Portainer kannst du Stacks über die Weboberfläche erstellen und verwalten – entweder durch Eingabe der Docker Compose YAML oder durch Upload einer Datei.

Grundaufbau einer docker-compose.yml

                YAML
version: '3.8'

services:
  web:                        # Service-Name
    image: nginx:latest      # Docker Image
    ports:
      - "8080:80"              # Port-Mapping (Host:Container)
    volumes:
      - ./html:/usr/share/nginx/html  # Volume Mount
    restart: unless-stopped  # Neustart-Policy

volumes:
  daten:                      # Named Volume
    driver: local
            

Wichtige Konzepte

Services: Die einzelnen Container (z.B. web, db, cache)
Image: Das Docker-Image, das verwendet wird
Ports: Port-Mapping zwischen Host und Container
Volumes: Persistente Datenspeicherung
Environment: Umgebungsvariablen für Konfiguration
Networks: Container-Netzwerke für Kommunikation
Restart: Neustart-Policy (always, unless-stopped, on-failure)

4. 10 Praxis-Projekte mit Portainer

Hier sind 10 spannende Server-Projekte, die du mit Portainer umsetzen kannst – von einfach bis fortgeschritten. Jedes Projekt enthält eine vollständige Docker Compose Konfiguration.

PROJEKT 01

WordPress

Blog & CMS mit Datenbank

Die weltweit beliebteste CMS-Plattform. Perfekt für Blogs, Unternehmenswebseiten und Online-Shops.

WordPress + MySQL
phpMyAdmin optional
Themes & Plugins
SEO-freundlich

Schwierigkeit:

PROJEKT 02

Nextcloud

Eigene Cloud-Storage-Lösung

Die Open-Source-Alternative zu Dropbox und Google Drive. Dateien, Kalender, Kontakte und mehr.

Dateisynchronisation
Kalender & Kontakte
Office-Integration
Mobile Apps

Schwierigkeit:

PROJEKT 03

Pi-hole

Netzwerkweiter Werbeblocker

DNS-basierter Werbeblocker für das gesamte Netzwerk. Blockiert Werbung, Tracker und Malware-Domains.

Netzwerkweiter Schutz
Web-Interface
Query-Statistiken
Custom Blocklists

Schwierigkeit:

PROJEKT 04

Home Assistant

Smart Home Zentrale

Die führende Open-Source-Plattform für Smart Home Automation. Unterstützt tausende Geräte.

2000+ Integrationen
Automatisierungen
Dashboards
Voice Assistant

Schwierigkeit:

PROJEKT 05

Jellyfin

Eigener Media-Server

Die Open-Source-Alternative zu Plex. Streams Filme, Serien und Musik auf alle Geräte.

Kein Abo nötig
Hardware-Transcoding
Mobile Apps
Live-TV Support

Schwierigkeit:

PROJEKT 06

Grafana + Prometheus

Monitoring & Visualisierung

Professionelles Monitoring für Server und Anwendungen. Metriken sammeln und visualisieren.

Echtzeit-Dashboards
Alerts & Benachrichtigungen
100+ Datenquellen
Export & Sharing

Schwierigkeit:

PROJEKT 07

Gitea

Eigener Git-Server

Leichtgewichtige Git-Hosting-Plattform. Die Open-Source-Alternative zu GitHub und GitLab.

Git Repositories
Issue Tracker
CI/CD (Gitea Actions)
Pull Requests

Schwierigkeit:

PROJEKT 08

Vaultwarden

Passwort-Manager

Leichtgewichtiger Bitwarden-kompatibler Server für sicheres Passwort-Management.

Bitwarden-kompatibel
Browser-Extensions
Mobile Apps
2FA Support

Schwierigkeit:

PROJEKT 09

Nginx Proxy Manager

Reverse Proxy mit SSL

Einfacher Reverse Proxy mit automatischem Let's Encrypt SSL und Web-Interface.

Let's Encrypt SSL
Web-Interface
Custom Domains
Access Lists

Schwierigkeit:

PROJEKT 10

Minecraft Server

Eigener Gameserver

Eigener Minecraft-Server für dich und deine Freunde. Vanilla, Spigot oder Paper.

Vanilla/Spigot/Paper
Plugin-Support
Backups
RCON Access

Schwierigkeit:

Projekt 1: WordPress Stack

Docker Compose für WordPress

Dieser Stack erstellt einen WordPress-Container mit einer MySQL-Datenbank. Beide Container kommunizieren über ein internes Docker-Netzwerk.

                YAML
version: '3.8'

services:
  db:
    image: mysql:8.0
    volumes:
      - db_data:/var/lib/mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: dein_sicheres_passwort
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wp_user
      MYSQL_PASSWORD: wp_passwort

  wordpress:
    image: wordpress:latest
    depends_on:
      - db
    ports:
      - "8080:80"
    restart: unless-stopped
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wp_user
      WORDPRESS_DB_PASSWORD: wp_passwort
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp-content:/var/www/html/wp-content

volumes:
  db_data:
            

Port 8080 → WordPress MySQL intern (3306)

                 So deployest du den Stack
                In Portainer: Stacks → Add stack
Name eingeben: wordpress
Oben genannten Code in den Editor einfügen
Passwörter anpassen!
Auf Deploy the stack klicken
WordPress unter http://dein-server:8080 aufrufen

            

Projekt 3: Pi-hole Stack

Docker Compose für Pi-hole

Pi-hole als DNS-Server im Netzwerk. Blockiert Werbung und Tracker auf allen Geräten.

                YAML
version: '3.8'

services:
  pihole:
    image: pihole/pihole:latest
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8081:80/tcp"
    environment:
      TZ: 'Europe/Berlin'
      WEBPASSWORD: dein_admin_passwort
    volumes:
      - ./pihole/etc:/etc/pihole
      - ./pihole/dnsmasq:/etc/dnsmasq.d
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
            

Port 53 → DNS Port 8081 → Web-Interface

                 Nach der Installation
                Im Router den DNS-Server auf die IP deines Servers ändern
Web-Interface unter http://dein-server:8081/admin
Blocklists unter Group Management → Adlists hinzufügen
Statistiken im Dashboard beobachten

            

Projekt 4: Home Assistant Stack

Docker Compose für Home Assistant

Home Assistant als Smart-Home-Zentrale. Steuert Lampen, Sensoren, Thermostate und mehr.

                YAML
version: '3.8'

services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    volumes:
      - ./ha-config:/config
      - /etc/localtime:/etc/localtime:ro
      - /run/dbus:/run/dbus:ro  # Für Bluetooth-Integration
    restart: unless-stopped
    privileged: true
    network_mode: host
            

Port 8123 → Web-Interface Host-Netzwerk

                 Erste Schritte
                Web-Interface unter http://dein-server:8123
Ersten Admin-Account erstellen
Standort und Zeitzone konfigurieren
Integrationen hinzufügen (z.B. Philips Hue, Sonoff, Tuya)
Automatisierungen erstellen

            

Projekt 7: Gitea Stack

Docker Compose für Gitea

Gitea als eigener Git-Server. Leichtgewichtig, schnell und mit vielen Features.

                YAML
version: '3.8'

services:
  gitea:
    image: gitea/gitea:latest
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=sqlite3
    volumes:
      - ./gitea-data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"  # Web-Interface
      - "2222:22"    # SSH
    restart: unless-stopped
            

Port 3000 → Web-Interface Port 2222 → SSH

 Git-Repository klonen
                    BASH
# Repository klonen
git clone ssh://git@dein-server:2222/username/repo.git

# Oder per HTTP
git clone http://dein-server:3000/username/repo.git
                

5. Best Practices für Portainer & Docker

Die wichtigsten Empfehlungen für einen sicheren und stabilen Betrieb deiner Container:

Sicherheit

Starke Passwörter für alle Services
Portainer mit 2FA schützen
Nur notwendige Ports freigeben
Regelmäßige Security Updates
Reverse Proxy mit SSL nutzen
Firewall-Regeln konfigurieren

Backup-Strategie

Regelmäßige Backups der Volumes
Docker Compose Dateien versionieren (Git)
3-2-1-Regel für Backups
Off-Site Backups (Cloud/NAS)
Recovery regelmäßig testen
Automatisierte Backup-Scripts

Ressourcen-Limits

CPU- und RAM-Limits setzen
Container-Monitoring einrichten
Alerts bei hohen Werten
Log-Rotation konfigurieren
Unnötige Images löschen
Regelmäßige System-Cleanup

Updates & Wartung

Regelmäßige Image-Updates
Watchtower für Auto-Updates
Changelogs vor Update prüfen
Backup vor重大 Updates
Test-Updates zuerst testen
Rollback-Plan bereithalten

Netzwerk-Sicherheit

Docker-Netzwerke nutzen
Container nur intern exponieren
Reverse Proxy für SSL
VLANs für Trennung
Fail2Ban für SSH-Schutz
Regelmäßige Netzwerk-Audits

Logging & Monitoring

Zentrales Logging (ELK/Loki)
Container-Logs überwachen
Alerts bei Fehlern
Performance-Metriken sammeln
Grafana-Dashboards erstellen
Log-Retention konfigurieren

Watchtower – Auto-Updates für Container

Watchtower überwacht deine Container und aktualisiert sie automatisch, wenn neue Images verfügbar sind:

                YAML
version: '3.8'

services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 3600 --cleanup  # Stündlich prüfen
    restart: unless-stopped
            

6. FAQ – Häufige Fragen

Häufige Fragen & Troubleshooting

Wie sichere ich meine Portainer-Konfiguration?

Portainer speichert alle Daten im Volume portainer_data. Du kannst dieses Volume regelmäßig sichern:

                        BASH
sudo docker run --rm \
  -v portainer_data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/portainer-backup.tar.gz /data
                    

Zusätzlich solltest du deine Docker Compose Dateien in Git versionieren.

Ein Container startet nicht – was tun?

Prüfe die Logs des Containers in Portainer:

In Portainer: Containers → Container auswählen
Auf Logs klicken
Fehlermeldungen analysieren
Häufige Ursachen: Port-Konflikte, fehlende Volumes, falsche Umgebungsvariablen

Alternativ per CLI: docker logs container_name

Wie aktualisiere ich einen Container?

In Portainer:

Containers → Container auswählen
Recreate klicken
Häkchen bei Pull latest image setzen
Bestätigen

Bei Stacks: Stack bearbeiten und Update the stack klicken.

Wie richte ich SSL/HTTPS ein?

Nutze einen Reverse Proxy wie Nginx Proxy Manager oder Traefik:

Nginx Proxy Manager als Container deployen
Domain konfigurieren (DNS auf Server zeigen lassen)
Proxy Host anlegen
SSL-Zertifikat über Let's Encrypt beantragen
Weiterleitung auf internen Container-Port einstellen

Was ist der Unterschied zwischen Volume und Bind Mount?

Named Volumes (z.B. db_data:/var/lib/mysql):

Werden von Docker verwaltet
Portabel zwischen Hosts
Besser für Produktionsdaten

Bind Mounts (z.B. ./config:/config):

Direkter Zugriff auf Host-Dateisystem
Einfacher zu bearbeiten
Gut für Konfigurationsdateien

Wie überwache ich den Ressourcenverbrauch?

Portainer bietet eingebaute Statistiken:

Containers → Container auswählen → Stats
CPU, RAM, Netzwerk I/O in Echtzeit

Für professionelles Monitoring: Grafana + Prometheus Stack deployen (Projekt 6).

Wie setze ich Ressourcen-Limits für Container?

In der Docker Compose Datei:

                        YAML
services:
  mein-service:
    image: ...
    deploy:
      resources:
        limits:
          cpus: '2.0'
          memory: 2G
        reservations:
          cpus: '0.5'
          memory: 512M
                    

Portainer ist langsam – was tun?

Mögliche Ursachen und Lösungen:

Zu viele Container: Portainer kann bei 100+ Containern langsamer werden
Wenig RAM: Mindestens 2 GB RAM für Portainer empfehlen
Alte Images: docker system prune aufräumen
Logs: Log-Rotation konfigurieren

Zusammenfassung

             Die wichtigsten Punkte
            Portainer: Webbasierte Docker-Verwaltung mit intuitiver GUI
Installation: Docker + Portainer CE in wenigen Schritten
Stacks: Multi-Container-Setups mit Docker Compose
10 Projekte: WordPress, Nextcloud, Pi-hole, Home Assistant, Jellyfin, Grafana, Gitea, Vaultwarden, Nginx Proxy Manager, Minecraft
Best Practices: Sicherheit, Backup, Ressourcen-Limits, Updates
Monitoring: Eingebaute Stats + Grafana für professionelle Überwachung
Auto-Updates: Watchtower für automatische Container-Updates
SSL/HTTPS: Reverse Proxy (Nginx Proxy Manager) für sichere Verbindungen
Self-Hosting: Eigene Dienste betreiben statt Cloud-Services nutzen
Community: Große Community, viele Templates und Tutorials verfügbar

        

Nächste Schritte

Bereit, dein erstes Projekt zu starten? Hier ein empfohlener Weg:

Anfänger: Starte mit Pi-hole (einfach, sofortiger Nutzen)
Fortgeschritten: WordPress oder Nextcloud (komplexere Setups)
Profi: Monitoring-Stack (Grafana + Prometheus) oder Full Home Lab

Weiterführende Themen

Was ist ein Server?

Grundlagen zu Servern – Arten, Komponenten und Einsatzgebiete.

Zu Server-Grundlagen

Server-Betriebssysteme

Linux-Distributionen für Server – Ubuntu, Debian, CentOS und mehr.

Zu Server-Betriebssystemen

Server-Sicherheit

Sicherheit für Einsteiger – Firewall, SSH, Updates und mehr.

Zur Server-Sicherheit

Server-FAQ & Tipps

Häufige Fragen und praktische Tipps für den Server-Betrieb.

Zu FAQ & Tipps