Prepaid Hoster FAQ

Ja, auf jedem vServer von Prepaid-Hoster kannst du Docker ohne Einschränkungen nutzen. Alle unsere vServer laufen auf KVM, also mit eigenem Kernel. Docker, Docker Compose und Images vom Docker Hub laufen darauf genauso wie auf einem eigenen Rechner. Hier erfährst du, was Docker ist, wie du es auf Debian oder Ubuntu installierst, wie deine Daten Neustarts überleben und welche Projekte sich auf einem vServer mit Docker lohnen.

Den App-Installer im Cloud Manager brauchst du dafür nicht: Docker ist dort derzeit nicht enthalten, die Installation über die offizielle Paketquelle dauert aber nur ein paar Minuten.

Was ist Docker?

Docker ist eine Plattform, die Anwendungen in Containern startet. Ein Container bringt alles mit, was die Anwendung braucht: Programm, Bibliotheken, Konfiguration. Die Vorlage dafür heißt Image. Aus einem Image startest du beliebig viele Container, und jeder läuft auf jedem Linux-Server gleich.

Spannend ist der Vergleich mit deinem vServer selbst. Ein vServer ist ein virtueller Server: KVM teilt einen physischen Server in mehrere Maschinen mit eigenem Kernel, eigenem Speicher und eigenem Betriebssystem auf. Docker macht eine Ebene tiefer etwas Ähnliches. Jeder Container bekommt ein eigenes Dateisystem, ein eigenes Netzwerk und eine eigene Prozessliste, und du kannst ihm CPU und RAM begrenzen. Ein Container ist damit fast schon ein vServer auf deinem vServer.

Der Unterschied: Alle Container teilen sich den Kernel deines vServers. Deshalb starten sie in Sekunden und brauchen kaum Overhead. Gleichzeitig ist die Trennung schwächer als zwischen zwei virtuellen Maschinen. Ein Container ist ein gut abgeschotteter Prozess, kein vollständiger Server.

	vServer (KVM)	Docker-Container
Kernel	eigener Kernel	teilt den Kernel des vServers
Start	Minuten (Installation), Sekunden (Neustart)	Sekunden
Betriebssystem	Linux oder Windows Server	Linux-Userland aus dem Image
Isolation	Hardware-Virtualisierung	Namespaces und cgroups im Kernel
Typischer Einsatz	ganzer Server mit Root-Zugriff	eine Anwendung pro Container

Warum Docker auf KVM problemlos läuft

Docker greift tief in den Kernel ein (Namespaces, cgroups, Overlay-Dateisystem, Paketfilter). Bei Container-Virtualisierungen wie dem früheren OpenVZ teilt sich der Gast den Kernel mit dem Host, dort lief Docker deshalb nur eingeschränkt oder gar nicht. Bei KVM hast du einen eigenen Kernel und volle Kontrolle darüber, Docker funktioniert ohne Sonderwege. Mehr zum Ende von OpenVZ bei uns liest du unter vServer mit OpenVZ wurden eingestellt.

Eine Grenze gibt es: Verschachtelte Virtualisierung ist auf unseren KVM-vServern deaktiviert. Docker-Container laufen, eigene virtuelle Maschinen (KVM, VirtualBox, Proxmox) oder Werkzeuge, die intern eine VM starten, aber nicht. Details stehen in Kann ich auf meinem vServer selbst virtualisieren?

Vorteile von Docker auf dem vServer

• Sauberes System: Jede Anwendung bringt ihre Abhängigkeiten im Image mit. PHP 8.1 für das eine Projekt und PHP 8.4 für das andere vertragen sich, ohne dass du am Grundsystem herumbaust.
• Reproduzierbar: Eine Compose-Datei beschreibt dein komplettes Setup. Auf einem neuen Server tippst du docker compose up -d und hast denselben Stand.
• Schnelle Updates und Rollbacks: Neues Image ziehen, Container neu starten. Klappt etwas nicht, gehst du auf den vorherigen Tag zurück.
• Mehrere Dienste auf einem Server: Webseite, Datenbank, Monitoring und Bot laufen getrennt voneinander auf einem vServer.
• Wenig Overhead: Container teilen sich den Kernel. Der Großteil von CPU und RAM bleibt für deine Anwendungen.
• Riesige Auswahl: Für fast jede bekannte Server-Software gibt es fertige Images auf dem Docker Hub.
• Kein Vendor-Lock-in: Deine Compose-Dateien und Volumes laufen bei jedem Linux-Server weiter.

Welcher vServer passt für Docker?

Docker läuft auf allen unseren Linux-vServern. Die Docker Engine selbst braucht wenig, den Bedarf bestimmen deine Container. Als Faustregel: Ein einzelner kleiner Dienst läuft mit 1 GB RAM, ein Stack aus Webanwendung, Datenbank und Reverse Proxy fühlt sich ab 2 bis 4 GB RAM wohl. Images und Volumes belegen schnell einige GB, plane den Speicher also großzügig.

• KVM Root 3.5 (konfigurierbar): 1 bis 14 Kerne, 1 bis 32 GB RAM, 50 bis 400 GB NVMe, IPv4 und ein /64-IPv6-Netz inklusive. Die flexibelste Wahl für Docker, Ressourcen lassen sich später per Upgrade anpassen.
• Smart Value: günstige Pakete mit 1 bis 12 GB RAM. Standardmäßig nur IPv6, eine IPv4-Adresse kannst du als Option dazubuchen. Beachte dazu den Abschnitt zu IPv6 weiter unten.
• Smart Essential: SSH-only-Server mit IPv4 und IPv6 inklusive und wählbarem Speicher. Gut für Entwickler, die alles per Terminal und Compose erledigen.
• Ryzen VPS: hohe Single-Core-Leistung, sinnvoll für rechenlastige Container, etwa Gameserver.

Als Betriebssystem empfehlen wir Debian 13 oder Debian 12, alternativ Ubuntu 24.04 oder 22.04. Diese Versionen unterstützt Docker offiziell. Debian 11 und Ubuntu 20.04 stehen bei Docker nicht mehr auf der Liste, installiere dort lieber neu. Welche Images wir anbieten, steht unter Welche Betriebssysteme stehen zur Verfügung? Einen passenden Server findest du auf unserer Seite zu Docker vServern.

Docker installieren

Installiere Docker aus der offiziellen Paketquelle von Docker. Die Pakete docker.io aus den Debian- oder Ubuntu-Quellen sind oft deutlich älter und bringen Compose nicht als aktuelles Plugin mit. Die folgenden Befehle gehen davon aus, dass du als root per SSH angemeldet bist. Arbeitest du mit einem normalen Benutzer, setze sudo davor.

Schritt 1: System aktualisieren und alte Pakete entfernen

Auf einem frisch installierten Server ist meist nichts zu entfernen, der Befehl schadet aber nicht. Er entfernt inoffizielle Docker-Pakete, die mit der offiziellen Version kollidieren würden.

apt update && apt upgrade -y
apt remove $(dpkg --get-selections docker.io docker-compose docker-doc docker-buildx podman-docker containerd runc | cut -f1)

Schritt 2: Docker-Paketquelle einrichten

Für Debian:

apt install -y ca-certificates curl
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

apt update

Für Ubuntu ersetzt du in der GPG-Adresse und in der Zeile URIs jeweils debian durch ubuntu:

apt install -y ca-certificates curl
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

apt update

Schritt 3: Docker Engine und Compose installieren

apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Docker startet danach automatisch und ist für den Systemstart aktiviert.

Schritt 4: Installation prüfen

systemctl status docker
docker run --rm hello-world
docker compose version

Gibt hello-world eine Begrüßung aus, ist Docker einsatzbereit. Updates von Docker kommen ab jetzt ganz normal mit apt update && apt upgrade. Wie du Updates generell im Griff behältst, steht in Mein Linux Server hat Updates! Was jetzt?

Optional: Docker ohne root nutzen

Willst du Docker mit einem normalen Benutzer bedienen, füge ihn der Gruppe docker hinzu und melde dich neu an:

usermod -aG docker deinbenutzer

Wichtig: Wer in der Gruppe docker ist, hat praktisch root-Rechte auf dem Server. Nimm dort also nur Benutzer auf, denen du auch root geben würdest. Wer mehr Abschottung möchte, schaut sich den Rootless-Modus von Docker an.

Schnell zum Testen: das Installationsskript

Docker bietet unter get.docker.com ein Skript, das die Paketquelle automatisch einrichtet. Für Testserver ist das bequem, für den Dauerbetrieb empfiehlt Docker selbst den Weg über die Paketquelle oben. Schau dir das Skript vor dem Ausführen an:

curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh --dry-run
sh get-docker.sh

Daten dauerhaft speichern

Container sind zum Wegwerfen gedacht. Löschst du einen Container oder ersetzt ihn durch ein neueres Image, ist alles weg, was nur im Container lag. Datenbanken, Uploads und Konfigurationen gehören deshalb in ein Volume oder einen Bind Mount.

Volumes: von Docker verwaltet

Volumes legt Docker selbst unter /var/lib/docker/volumes/ an. Das ist der empfohlene Weg für Datenbanken und Anwendungsdaten.

docker volume create webdaten
docker run -d --name web --restart unless-stopped \
  -v webdaten:/usr/share/nginx/html \
  -p 8080:80 nginx:stable

docker volume ls
docker volume inspect webdaten

Bind Mounts: ein Ordner deines Servers

Mit einem Bind Mount bindest du einen bestimmten Ordner deines vServers in den Container ein. Praktisch für Konfigurationsdateien, die du direkt per SFTP oder im Editor bearbeiten willst. Mit :ro darf der Container nur lesen.

mkdir -p /srv/web
docker run -d --name web2 --restart unless-stopped \
  -v /srv/web:/usr/share/nginx/html:ro \
  -p 8081:80 nginx:stable

Volumes sichern

Unsere kostenlosen Backups sichern die komplette Festplatte deines vServers, also auch alle Volumes. Sie laufen im laufenden Betrieb. Bei Datenbanken solltest du deshalb zusätzlich einen Dump anlegen, damit du einen garantiert konsistenten Stand hast. Ein einzelnes Volume packst du so in ein Archiv:

mkdir -p /root/backup
docker run --rm -v webdaten:/daten:ro -v /root/backup:/backup alpine \
  tar czf /backup/webdaten.tar.gz -C /daten .

Vor größeren Updates lohnt sich ein Snapshot im Cloud Manager. Geht etwas schief, bist du per Klick wieder auf dem alten Stand. Snapshots werden nach 48 Stunden automatisch gelöscht und ersetzen kein Backup.

Docker Compose

Sobald eine Anwendung aus mehreren Containern besteht, wird docker run unübersichtlich. Mit Docker Compose beschreibst du alle Container, Netzwerke und Volumes in einer Datei namens compose.yaml und startest alles mit einem Befehl. Compose ist mit dem Paket docker-compose-plugin bereits installiert. Der Befehl lautet docker compose mit Leerzeichen. Das alte docker-compose mit Bindestrich ist veraltet.

Beispiel: WordPress mit MariaDB

Lege einen Projektordner an und darin die Datei compose.yaml:

mkdir -p /opt/wordpress && cd /opt/wordpress
nano compose.yaml

services:
  db:
    image: mariadb:11
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: wordpress
      MARIADB_USER: wordpress
      MARIADB_PASSWORD: ${DB_PASSWORD}
      MARIADB_RANDOM_ROOT_PASSWORD: "1"
    volumes:
      - db:/var/lib/mysql

  wordpress:
    image: wordpress:latest
    restart: unless-stopped
    depends_on:
      - db
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_NAME: wordpress
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
    ports:
      - "8080:80"
    volumes:
      - wp:/var/www/html

volumes:
  db:
  wp:

Das Passwort legst du in einer Datei .env im selben Ordner ab, damit es nicht in der Compose-Datei steht:

echo "DB_PASSWORD=$(openssl rand -base64 24)" > .env
chmod 600 .env

Danach erreichst du WordPress unter http://62.68.75.69:8080, wobei du die IP natürlich durch die deines Servers ersetzt. Für den echten Betrieb mit Domain und HTTPS setzt du einen Reverse Proxy davor (siehe Anwendungsbeispiele).

Die wichtigsten Compose-Befehle

Alle Befehle führst du im Projektordner aus:

docker compose up -d                  # alles starten (im Hintergrund)
docker compose ps                     # Status der Container
docker compose logs -f                # Logs live verfolgen
docker compose pull && docker compose up -d   # Images aktualisieren
docker compose down                   # stoppen und Container entfernen (Volumes bleiben)
docker compose exec db bash           # Shell im Container "db"

Mit restart: unless-stopped starten deine Container nach einem Neustart des vServers automatisch wieder. Einen eigenen systemd-Dienst brauchst du dafür nicht.

Docker Hub

Der Docker Hub ist die zentrale Registry, aus der Docker standardmäßig Images lädt. Schreibst du image: nginx:stable, holt Docker das Image von dort.

• Vertrauenswürdige Images wählen: Achte auf die Kennzeichnung „Docker Official Image“ oder „Verified Publisher“. Bei Images unbekannter Herkunft läuft fremder Code auf deinem Server.
• Tags festlegen: latest ist bequem, kann aber beim nächsten pull eine neue Hauptversion bringen. Für Datenbanken nimmst du besser eine feste Version wie mariadb:11 oder postgres:17.
• Images suchen und laden: docker search nginx und docker pull nginx:stable.

Pull-Limits

Der Docker Hub begrenzt Downloads ohne Anmeldung auf 100 Pulls in 6 Stunden pro IPv4-Adresse beziehungsweise pro IPv6-/64-Netz. Mit einem kostenlosen Docker-Konto sind es 200 Pulls in 6 Stunden. Jeder vServer bei uns hat eine eigene IPv4 bzw. ein eigenes /64-Netz, das Limit teilst du also mit niemandem. Wer viele Images zieht, etwa in CI-Pipelines, meldet sich an:

docker login

Neben dem Docker Hub gibt es weitere Registries wie ghcr.io (GitHub) oder quay.io. Die nutzt du genauso, indem du den Registry-Namen vor das Image schreibst, zum Beispiel ghcr.io/benutzer/projekt:1.0.

Docker auf einem Smart Value mit nur IPv6

Unsere Smart Value Server haben standardmäßig nur IPv6. Der Docker Hub ist per IPv6 erreichbar, docker pull funktioniert also direkt. Zwei Dinge musst du aber wissen:

• Container brauchen ein IPv6-Netz. Das Standardnetz von Docker vergibt nur IPv4-Adressen. Auf einem Server ohne IPv4 kommen deine Container dann nicht ins Internet. Aktiviere IPv6 für das Netz deines Compose-Projekts, Docker vergibt dann automatisch ein privates IPv6-Netz und leitet den Verkehr nach außen weiter.
• Nicht jede Gegenstelle spricht IPv6. Manche Registries, APIs oder Update-Server sind nur per IPv4 erreichbar. Einen NAT64-Dienst bieten wir nicht an. Ob ein Ziel IPv6 kann, prüfst du mit dig AAAA ghcr.io. Kommt keine Adresse zurück, buchst du im Cloud Manager eine IPv4-Adresse dazu.

IPv6 für ein Compose-Projekt aktivierst du mit diesem Block am Ende der compose.yaml:

networks:
  default:
    enable_ipv6: true

Für einzelne Container mit docker run legst du ein eigenes Netz an und hängst den Container dort ein:

docker network create --ipv6 netz6
docker run -d --network netz6 -p 8080:80 nginx:stable

Wie du dich überhaupt mit einem reinen IPv6-Server verbindest, erklären wir in Mein Smart Value hat nur IPv6. Wie verbinde ich mich?

Docker Anwendungsbeispiele

Was Kunden bei uns typischerweise auf einem vServer mit Docker betreiben:

• Reverse Proxy mit HTTPS: Traefik, Caddy oder Nginx Proxy Manager nehmen Anfragen auf Port 80 und 443 an, holen automatisch Let’s-Encrypt-Zertifikate und verteilen den Verkehr per Domain auf deine Container. Die Basis für fast jedes Setup mit mehreren Diensten.
• Automatisierung mit n8n: n8n läuft als Container mit eigener Datenbank. Eine Anleitung findest du im n8n Installations-Guide.
• Eigene Cloud: Nextcloud mit Datenbank und Redis als Compose-Stack, deine Daten bleiben im Rechenzentrum in Offenbach am Main bei Frankfurt.
• Mailserver: Mailcow ist komplett auf Docker aufgebaut. Port 25 ist bei uns ausgehend offen. Achte auf einen passenden rDNS-Eintrag.
• Monitoring: Uptime Kuma überwacht deine Webseiten, Prometheus und Grafana zeigen die Auslastung deiner Container.
• Entwicklung und Git: Gitea oder Forgejo als eigener Git-Server, CI-Runner für GitHub Actions oder GitLab, Staging-Umgebungen für Laravel, Node.js oder Python.
• Passwortmanager: Vaultwarden als schlanker, selbst gehosteter Server für Bitwarden-Clients.
• Gameserver und Bots: Panels wie Pterodactyl starten Gameserver in Containern, Discord- und TeamSpeak-Bots laufen sauber getrennt nebeneinander.
• Webseiten und Shops: WordPress wie im Beispiel oben, aber auch Shopware oder Ghost lassen sich als Compose-Stack betreiben.

Häufige Stolpersteine

Veröffentlichte Ports umgehen die Firewall

Mit -p 8080:80 oder ports: trägt Docker eigene Paketfilter-Regeln ein. Diese greifen vor ufw oder firewalld. Ein Port, den du in ufw gesperrt hast, ist trotzdem aus dem Internet erreichbar, wenn ein Container ihn veröffentlicht. Bei uns sind auf Linux-Servern zudem alle Ports standardmäßig offen (Sind alle Ports freigegeben?).

Dienste, die nur intern erreichbar sein sollen (Datenbank, Admin-Oberfläche hinter dem Reverse Proxy), bindest du deshalb an localhost:

ports:
  - "127.0.0.1:8080:80"

Container im selben Compose-Projekt erreichen sich über den Dienstnamen (im Beispiel db), dafür brauchst du gar keinen veröffentlichten Port. Eigene Filterregeln für Container gehören in die iptables-Chain DOCKER-USER. Docker arbeitet standardmäßig mit iptables, auf aktuellen Debian- und Ubuntu-Systemen über das nftables-Backend von iptables. Eigene Regelsätze, die du direkt mit nft anlegst, unterstützt Docker im Standardmodus nicht. Seit Docker 29 gibt es ein eigenes nftables-Backend, es ist aber noch experimentell. Mehr zur Absicherung allgemein: Linux Server absichern.

Festplatte läuft voll

Alte Images, gestoppte Container und Build-Cache sammeln sich an. Den Verbrauch prüfst du so:

docker system df
docker image prune           # ungenutzte Images ohne Tag löschen
docker system prune          # gestoppte Container, ungenutzte Netze und Images aufräumen

Vorsicht mit docker system prune --volumes: Das löscht auch Volumes, die gerade kein Container nutzt, und damit eventuell deine Daten.

Ein zweiter Klassiker sind Container-Logs, die ohne Limit wachsen. Begrenze sie global in /etc/docker/daemon.json und starte Docker neu. Die Einstellung gilt für neu erstellte Container.

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

systemctl restart docker

Server wird langsam oder Load ist hoch

Container teilen sich CPU und RAM deines vServers. Mit docker stats siehst du live, welcher Container wie viel verbraucht. Einzelne Container begrenzt du in Compose mit cpus: "1.0" und mem_limit: 512m. Dauerhaft hohe Last zählt bei uns wie jede andere Last, siehe Load-Regel bei KVM. Reichen die Ressourcen nicht mehr, ist ein Upgrade im Cloud Manager meist der einfachste Weg.

„Cannot connect to the Docker daemon“

Entweder läuft der Dienst nicht (systemctl start docker, Fehler in journalctl -u docker) oder dein Benutzer ist nicht in der Gruppe docker. Nach usermod musst du dich einmal ab- und wieder anmelden.

Docker vServer mieten

Du suchst noch einen vServer mit Docker? Alle unsere Linux-vServer laufen auf KVM mit AMD EPYC oder Ryzen und NVMe im Rechenzentrum maincubes FRA01 in Offenbach am Main. Aufladen statt abonnieren: Du zahlst per Prepaid-Guthaben, ohne Mahnungen und ohne Bonitätsprüfung. Alle Pakete im Überblick findest du auf unserer Seite Docker Hosting: vServer mit Docker.

Noch Fragen zu Docker auf deinem Server? Schreib uns einfach über das Formular unten oder per Ticket.