TOR Server in Docker Container auf dem VPS installieren

Version: 25.11.01

In diesem Tutorial zeige ich Ihnen, wie Sie einen Tor-Server als Mittelknoten auf einem VPS installieren. Gleichzeitig erstellen Sie einen Proxy-Server, über den man per Browser (z. B. Firefox) die Tor-Verbindung nutzen kann, um anonym im Internet zu surfen. Dabei vermischt sich das eigene Surfverhalten mit den Anfragen, die über den Server laufen.

📥 Was benötigen Sie?
1. einen VPS Server mit öffentlicher IPv4 Adresse im Internet mit genügend Bandbreite / freiem Traffic (2,5TB im Monat möglich nach der Konfiguration unten)
2. Linux und SSH-Kenntnisse (Terminal)
3. Docker und Docker-Compose sind installiert (es wird aber auch nochmal ein Installationsskript gezeigt)
4. Die Überzeugung gegen Zensur und Freiheitsbeschränkungen im Internet vorzugehen ?

Wir starten und loggen uns auf den Server ein:

ssh Username@Server-IP

Wechseln Sie in Ihren Docker-Projekteordner, den ich in meinem Fall unter /home/ abgelegt habe.

cd /home/

Es wird ein Ordner Namens „tor“ erstellt:

mkdir tor

Und in diesen gewechselt:

cd tor

Falls Docker und Docker-Compose noch nicht installiert sind gibt es hier eine kurze Installationsanleitung. Diese kann auch gerne übersprungen werden:

Jetzt installieren Sie erst einmal Docker indem Sie im /home/tor/ Verzeichnis eine Datei Namens „install.sh“ erstellen:

nano /home/tor/install.sh

In die Datei kommt folgender Inhalt rein:

#!/usr/bin/env bash
# Script: docker-install-commander.sh
# Purpose: Install Docker & Docker Compose for Ubuntu/Debian
# Author: Tom Commander (IT-Service-Commander.de)
# Date: 2025-11-01

set -euo pipefail

# ===== Settings (optional) =====
# Additionally install the standalone docker-compose binary (besides the plugin)?
INSTALL_COMPOSE_STANDALONE=false
COMPOSE_VERSION="v2.30.3"  # only relevant if the above is true

# ===== Helper functions =====
need_cmd() { command -v "$1" >/dev/null 2>&1 || { echo "Error: '$1' is required."; exit 1; }; }
as_root()   { if [ "$(id -u)" -eq 0 ]; then bash -c "$*"; else sudo bash -c "$*"; fi; }

# ===== Detect system =====
need_cmd awk
if [ -r /etc/os-release ]; then
  . /etc/os-release
else
  echo "Error: /etc/os-release not found. Aborting."
  exit 1
fi

ID_LOWER="${ID,,}"                  # ubuntu | debian | linuxmint | ...
ARCH="$(dpkg --print-architecture)"

# Normalize to an upstream family + codename for Docker repo selection
FAMILY=""        # "ubuntu" or "debian"
CODENAME=""      # e.g., jammy/noble/bookworm

case "$ID_LOWER" in
  ubuntu)
    FAMILY="ubuntu"
    CODENAME="${VERSION_CODENAME:-}"
    ;;
  debian)
    FAMILY="debian"
    CODENAME="${VERSION_CODENAME:-}"
    ;;
  linuxmint)
    # Regular Linux Mint is Ubuntu-based -> use UBUNTU_CODENAME.
    # LMDE is Debian-based -> has DEBIAN_CODENAME.
    if [ -n "${UBUNTU_CODENAME:-}" ]; then
      FAMILY="ubuntu"
      CODENAME="$UBUNTU_CODENAME"
    elif [ -n "${DEBIAN_CODENAME:-}" ]; then
      FAMILY="debian"
      CODENAME="$DEBIAN_CODENAME"
    else
      echo "Linux Mint detected but could not determine upstream codename (UBUNTU_CODENAME/DEBIAN_CODENAME missing)."
      exit 1
    fi
    ;;
  *)
    echo "This script supports Ubuntu, Debian, and Linux Mint. Detected: ${ID_LOWER}"
    exit 1
    ;;
esac

if [[ -z "$CODENAME" ]]; then
  echo "Could not determine upstream codename. Please set VERSION_CODENAME/UBUNTU_CODENAME/DEBIAN_CODENAME."
  exit 1
fi

echo "Detected system: ${PRETTY_NAME:-$ID_LOWER} (family: $FAMILY, codename: $CODENAME, arch: $ARCH)"

# ===== Preparation =====
echo "[1/6] Updating package list and installing prerequisites..."
as_root "apt-get update -y"
as_root "apt-get install -y ca-certificates curl gnupg lsb-release"

# Ensure keyring directory exists
as_root "install -m 0755 -d /etc/apt/keyrings"

# ===== Docker GPG key =====
echo "[2/6] Installing Docker GPG key..."
KEY_DST="/etc/apt/keyrings/docker.gpg"
if [[ "$FAMILY" == "ubuntu" ]]; then
  as_root "curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o '$KEY_DST'"
else
  as_root "curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o '$KEY_DST'"
fi
as_root "chmod a+r '$KEY_DST'"

# ===== Add repository (idempotent) =====
echo "[3/6] Adding Docker APT repository..."
DOCKER_LIST="/etc/apt/sources.list.d/docker.list"
REPO_LINE="deb [arch=${ARCH} signed-by=${KEY_DST}] https://download.docker.com/linux/${FAMILY} ${CODENAME} stable"

if [ -f "$DOCKER_LIST" ] && grep -q "download.docker.com/linux" "$DOCKER_LIST"; then
  echo "Docker repository already exists: $DOCKER_LIST"
else
  as_root "echo '$REPO_LINE' > '$DOCKER_LIST'"
fi

# ===== Install Docker & Compose plugin =====
echo "[4/6] Installing Docker and Compose plugin..."
as_root "apt-get update -y"
as_root "apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin"

# ===== Enable and start Docker =====
echo "[5/6] Enabling and starting Docker service..."
as_root "systemctl enable docker >/dev/null 2>&1 || true"
as_root "systemctl restart docker"

# ===== Add user to docker group =====
if [ "$(id -u)" -ne 0 ]; then
  echo "[6/6] Adding user '$USER' to the 'docker' group..."
  as_root "usermod -aG docker '$USER'"
  echo "Note: Log out and back in (or run 'newgrp docker') for group changes to take effect."
else
  echo "[6/6] Running as root: skipping user group modification."
fi

# ===== Optional: Install standalone docker-compose binary =====
if [ "$INSTALL_COMPOSE_STANDALONE" = true ]; then
  echo "[Optional] Installing standalone docker-compose ${COMPOSE_VERSION}..."
  need_cmd uname
  as_root "curl -L \"https://github.com/docker/compose/releases/download/${COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)\" -o /usr/local/bin/docker-compose"
  as_root "chmod +x /usr/local/bin/docker-compose"
  echo "docker-compose version: $(/usr/local/bin/docker-compose --version || true)"
fi

# ===== Show versions =====
echo
echo "✅ Installation complete!"
echo "Docker:           $(docker --version 2>/dev/null || echo 'Not in PATH? Try logging out and back in.')"
echo "Docker Compose:   $(docker compose version 2>/dev/null || echo 'Plugin not found')"
echo
echo "Tip: Test your setup with ->  docker run --rm hello-world"

Anschließend führen Sie die Datei aus:

cd /home/tor
bash install.sh

Nach Abschluss des Skripts sind Docker und Docker-Compose installiert.

Nun widmen Sie sich dem Tor-Server und erstellen in dem Ordner /home/tor folgende Datei:

nano Dockerfile

In die Datei fügen Sie folgenden Inhalt ein und speichern diese ab – hierbei wird die aktuelle TorVersion 0.4.8.19 verwendet:

# Basis-Image mit aktueller Tor-Version
FROM ubuntu:24.04

# Basis-Tools installieren
RUN apt-get update && apt-get install -y \
    curl \
    gnupg2 \
    apt-transport-https \
    ca-certificates \
    python3 \
    python3-pip \
    git \
    locales \
    privoxy

# UTF-8 Locale setzen (für Nyx)
RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && \
    locale-gen

ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

# Offiziellen Tor-GPG-Schlüssel importieren
RUN curl -fsSL https://deb.torproject.org/torproject.org/A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89.asc \
    | gpg --dearmor -o /usr/share/keyrings/tor-archive-keyring.gpg

# Tor-Repository einbinden
RUN echo "deb [signed-by=/usr/share/keyrings/tor-archive-keyring.gpg] https://deb.torproject.org/torproject.org noble main" \
    > /etc/apt/sources.list.d/tor.list

# Tor installieren
RUN apt-get update && apt-get install -y \
    tor \
    deb.torproject.org-keyring && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

# Nyx installieren
RUN apt-get update && apt-get install -y nyx && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

# Konfigurationsdateien & Startskript kopieren
COPY privoxy.config /etc/privoxy/config
COPY start.sh /start.sh
RUN chmod +x /start.sh

# Ports freigeben
EXPOSE 9001 9030 8118

# Startkommando
CMD ["/start.sh"]

Angelegt wird eine neue Datei:

nano start.sh

Diese Datei sorgt dafür das Privoxy (unser Proxyserver über den Sie später über Port 8118 auf Tor zugreifen können) erst nach dem Start des Tor-Servers startet:

#!/bin/bash
set -e

# Starte Tor im Hintergrund
tor -f /etc/tor/torrc &

# Warte kurz, bis Tor initialisiert ist
sleep 5

# Wenn ein Terminal vorhanden ist, starte Nyx in einem neuen Prozess
if [ -t 1 ]; then
  echo "Starte Nyx zur Überwachung von Tor..."
  nyx &
fi

# Starte Privoxy im Vordergrund (wichtig für Docker!)
exec privoxy --no-daemon /etc/privoxy/config

Die nächste Datei die Sie anlegen:

nano torrc

Hier kommt folgender Inhalt hinein:

Nickname Nickname
ContactInfo contact@proton.me

ORPort 9001 IPv4Only
DirPort 9030
ControlPort 9051
CookieAuthentication 1
ExitRelay 0

DataDirectory /var/lib/tor

RelayBandwidthRate 1 MB
RelayBandwidthBurst 2 MB

Log notice stdout

#Address VPS-IP(optional)

Den Nickname Ihres Relays und die Kontakt-Emailadresse ändern Sie natürlich noch entsprechend ab. Das Tor Relay wird in unserem Beispiel nur als IPv4 Host betrieben, was einfacher umzusetzen ist.

Es folgt wieder eine neue Datei:

nano privoxy.config

Hierbei handelt es sich um die Konfigurationsdatei unseres Proxy-Servers:

listen-address  0.0.0.0:8118
forward-socks5t /               127.0.0.1:9050 .
logfile /dev/stdout

Nachdem Sie auch diese Datei erstellt haben, können Sie Ihr eigenes Docker-Image bauen (alles wird dabei in dem Pfad /home/tor/ abgespeichert und ausgeführt):

docker build -t tor-privoxy-nyx .

Sie haben nun Ihren eigenen Docker Container mit Tor-Privoxy erstellt. Das ganze kann mit dem Befehl „docker images“ überprüft werden. Hier müsste jetzt der entsprechende Container auftauchen:

⚙️ Basteln Sie noch die entsprechende Docker-Compose.yml um den Container gut und sicher zu starten:

nano docker-compose.yml

Die Datei wird im Ordner /home/tor gespeichert mit folgendem Inhalt:

version: '3.8'

services:
  tor-privoxy:
    build: .
    image: tor-privoxy-nyx
    container_name: tor-privoxy-nyx
    volumes:
      - ./torrc:/etc/tor/torrc
      - ./tor_data:/var/lib/tor
    ports:
      - "9001:9001"
      - "9030:9030"
      - "8118:8118"
    restart: always

Jetzt haben Sie alle Schritte erledigt um auf Ihrem VPS Server einen Tor Server als Mittelknoten laufen zu lassen. Nun können Sie den Container im Hintergrund starten:

docker compose up -d

Log-Dateien lassen Sie sich mit

docker logs -f tor-privoxy-nyx

anzeigen.

Wenn Sie in den Logs die „100%“ finden, haben Sie alles richtig gemacht:

Wichtig ist noch, dass die Ports 9001 und 9030 aus dem Internet erreichbar und in der Firewall freigegeben sind.

ACHTUNG: Port 8118 sollte aus Sicherheitsgründen entweder geblockt oder nur für Ihre eigene IP freigegeben werden. Das ist der Proxyserver.

Für den Proxyserver gibt es noch den folgenden Funkionstest:

curl --proxy http://localhost:8118 https://check.torproject.org/

Hier sollte eine Bestätigung erscheinen, dass eine Verbindung über TOR möglich war.

✅ Was haben Sie in dem Tutorial nun erreicht?

TOR läuft in der aktuellsten Version in einem Docker Container auf dem VPS Server
Privoxy und NYX sind mit installiert
Fingerprint und RSA Schlüssel werden außerhalb des Containers gespeichert
Der Tor Server ist öffentlich erreichbar über die Ports TCP Ports 9001 und 9030
Der Proxyserver, der Tor verwendet, ist über IP:8118 erreichbar und kann so z.B. im Browser als Proxy angegeben werden (ACHTUNG: Nur für die eigene IP am besten freigeben!)
Sie setzen sich aktiv für Freiheit im Internet ein ?

Statistiken (NYX) können Sie mit folgenden Befehlen abrufen: