● LIVE CODEundKRAM // EST. IRGENDWANNBEST VIEWED WITH YOUR OWN EYES // 1024x768 // NO COOKIES
← Zurück ins Kramarchiv

Node64 ohne Node64: Der einfache Docker-Stack fürs Homelab

Reverse Proxy, Monitoring, DNS-Filter und DynDNS. Dafür braucht es keine Schaltzentrale und keinen Monolithen. Vier Container, eine compose.yaml, fertig.

▤ LESEN.EXE↳ Kommentare direkt öffnen

Wir haben über Node64 gemeckert.

Wir haben über IPv64 gemeckert.

Jetzt kommt der gefährliche Teil:

Selber besser machen.

Denn natürlich kann ich den ganzen Tag sagen:

Monitoring gibt es längst.

DNS gibt es längst.

Reverse Proxy gibt es längst.

DynDNS gibt es ungefähr seit der Erfindung des Internetanschlusses mit wechselnder IP.

Irgendwann kommt aber völlig zu Recht:

„Dann zeig doch mal.“

Bitte.

Vier Aufgaben.

Vier Programme.

Vier Container.

Eine compose.yaml.

Kein Node.

Kein Portal.

Keine Schaltzentrale.

Kein Programm, das morgens Reverse Proxy spielt und nachmittags noch schnell DNS, Monitoring, Honeypot und Weltfrieden erledigt.

Caddy macht Reverse Proxy.

Uptime Kuma überwacht.

AdGuard Home macht DNS und Filterung.

ddclient aktualisiert DynDNS.

Das Konzept dahinter ist erschreckend:

Jedes Programm macht das, wofür es gebaut wurde.

Ich weiß.

2026 und wir sind schon wieder bei revolutionären Ideen.

Herrlich.

Unsoziale Software.

Genau mein Ding.

Inhaltsverzeichnis

Was wir bauen

Der Stack:

Tabelle im Artikel
AufgabeDienst
Reverse ProxyCaddy
MonitoringUptime Kuma
DNS + FilterAdGuard Home
DynDNSddclient

Nicht Kubernetes.

Nicht Proxmox in Proxmox in Proxmox.

Keine Cloud-native Multi-Tenant Service Fabric für den Raspberry Pi hinter dem Fernseher.

Ein normales Homelab.

Caddy ist ein etablierter Webserver und Reverse Proxy mit automatischer HTTPS-Verwaltung. Uptime Kuma ist fürs Monitoring da. AdGuard Home kümmert sich um DNS. ddclient aktualisiert DNS-Einträge bei wechselnden IP-Adressen.

Und vor allem:

Keiner muss wissen, dass die anderen existieren.

Das ist kein Nachteil.

Das ist der verdammte Punkt.

Erstmal nicht das ganze Internet reinlassen

Bevor wir Docker anschmeißen, eine wichtige Regel:

Admin-Oberflächen gehören nicht einfach ins Internet.

Deshalb steht hier später nicht:

ports:
  - "3001:3001"

sondern beispielsweise:

ports:
  - "${LAN_IP}:3001:3001"

Damit wird der Port nur an die LAN-Adresse unseres Docker-Servers gebunden.

Beispiel:

192.168.178.10

Uptime Kuma:

LAN.

AdGuard-Administration:

LAN.

DNS:

LAN.

Und Caddy zunächst ebenfalls:

LAN.

Keine Routerfreigabe für 3000.

Keine Routerfreigabe für 3001.

Port 53 nicht fröhlich ins Internet stellen, weil „DNS braucht doch Port 53“.

Nein, Kevin.

Dein Fernseher im Wohnzimmer soll ihn erreichen. Nicht Moldawien.

Wenn wir später bewusst einen Webdienst über Caddy veröffentlichen wollen, können wir das tun.

Bewusst.

Dieses Wort ist wichtig.

Die Verzeichnisse

Alles liegt sichtbar unter einem Verzeichnis:

homelab/
├── compose.yaml
├── .env
├── caddy/
│   ├── conf/
│   │   └── Caddyfile
│   ├── data/
│   ├── config/
│   └── logs/
├── uptime-kuma/
├── adguard/
│   ├── conf/
│   └── work/
└── ddclient/
    └── ddclient.conf

Keine Docker-Volumes mit Namen wie:

homelab_caddy_data

die irgendwo unter Docker wohnen und bei denen der Einsteiger erstmal Google fragen darf:

„Wo ist mein Zeug?“

Named Volumes sind nicht schlecht.

Aber für diese Anleitung möchte ich sehen:

Das sind meine Daten.

Da liegen sie.

Da sichere ich sie.

Fertig.

Verzeichnisse anlegen:

mkdir -p homelab/caddy/{conf,data,config,logs}
mkdir -p homelab/uptime-kuma
mkdir -p homelab/adguard/{conf,work}
mkdir -p homelab/ddclient

cd homelab

touch caddy/conf/Caddyfile
touch ddclient/ddclient.conf

Die ddclient-Datei wird später Zugangsdaten oder API-Tokens enthalten:

chmod 600 ddclient/ddclient.conf

Nicht jeder Benutzer auf dem Server braucht Leserechte darauf.

Auch nicht derjenige, der „nur ganz kurz was testen“ möchte.

Gerade der nicht.

Caddy bekommt mehrere Verzeichnisse, weil Caddy dort unterschiedliche Dinge speichert. Besonders /data ist wichtig: Dort liegen unter anderem Zertifikate, private Schlüssel und weitere TLS-Daten. Caddy warnt ausdrücklich davor, dieses Verzeichnis wie einen löschbaren Cache zu behandeln.

Also:

./caddy/data

Backup.

Nicht:

rm -rf

und anschließend überrascht gucken.

Unsere .env

Jetzt:

LAN_IP=192.168.178.10
TZ=Europe/Berlin
PUID=1000
PGID=1000

Natürlich ersetzt du:

192.168.178.10

durch die feste interne IP deines Docker-Servers.

Nicht die öffentliche IP.

Nicht die FritzBox.

Nicht irgendeine Adresse, die du gestern noch im Browser gesehen hast.

Der Rechner.

Auf dem Docker läuft.

PUID und PGID bekommen wir unter Linux mit:

id

Zum Beispiel:

uid=1000(tim) gid=1000(tim)

Dann passen:

PUID=1000
PGID=1000

LinuxServer empfiehlt genau dieses Mapping, damit die Dateien im eingebundenen Konfigurationsverzeichnis dem richtigen Host-Benutzer gehören.

Die komplette compose.yaml

Jetzt das eigentliche Monster.

Festhalten.

Es hat ungefähr 60 Zeilen.

services:

  caddy:
    image: caddy:2
    restart: unless-stopped

    ports:
      - "${LAN_IP}:80:80"
      - "${LAN_IP}:443:443"
      - "${LAN_IP}:443:443/udp"

    volumes:
      - ./caddy/conf:/etc/caddy:ro
      - ./caddy/data:/data
      - ./caddy/config:/config
      - ./caddy/logs:/var/log/caddy

    networks:
      - homelab


  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped

    ports:
      - "${LAN_IP}:3001:3001"

    volumes:
      - ./uptime-kuma:/app/data

    networks:
      - homelab


  adguard-home:
    image: adguard/adguardhome
    restart: unless-stopped

    ports:
      - "${LAN_IP}:53:53/tcp"
      - "${LAN_IP}:53:53/udp"
      - "${LAN_IP}:3000:3000/tcp"

    volumes:
      - ./adguard/work:/opt/adguardhome/work
      - ./adguard/conf:/opt/adguardhome/conf

    networks:
      - homelab


  ddclient:
    image: lscr.io/linuxserver/ddclient:latest
    restart: unless-stopped

    environment:
      PUID: "${PUID}"
      PGID: "${PGID}"
      TZ: "${TZ}"

    volumes:
      - ./ddclient:/config

    networks:
      - homelab


networks:
  homelab:
    driver: bridge

Vier Container.

Und bemerkenswerterweise ist noch niemand gestorben.

Start:

docker compose pull
docker compose up -d

Status:

docker compose ps

Logs:

docker compose logs -f

Nur Caddy:

docker compose logs -f caddy

Nur Kuma neu starten:

docker compose restart uptime-kuma

Und jetzt der Teil, der bei Docker offenbar gern vergessen wird:

Dass dort vier Zeilen mit running stehen, ist kein Architekturproblem.

Wir müssen nicht alles in einen Prozess werfen, nur damit Portainer aufgeräumter aussieht.

Caddy: Reverse Proxy

Unsere Konfiguration liegt unter:

./caddy/conf/Caddyfile

Die offizielle Caddy-Docker-Dokumentation empfiehlt, das ganze Verzeichnis nach /etc/caddy einzubinden und nicht nur die einzelne Caddyfile. Bestimmte Editoren ersetzen beim Speichern nämlich die Datei beziehungsweise deren Inode, was bei einem einzelnen File-Mount Reloads unnötig hässlich machen kann.

Für den ersten Test machen wir es absichtlich langweilig:

:80 {
    respond "Caddy läuft."
}

Jetzt:

docker compose exec -w /etc/caddy caddy caddy reload

Browser:

http://192.168.178.10

Wenn dort steht:

Caddy läuft.

läuft Caddy.

Über HTTP.

Ohne Zertifikat.

Ohne Magie.

Ohne dass Let's Encrypt plötzlich deine FritzBox heiratet.

Perfekt.

Jetzt können wir beispielsweise Kuma über Caddy erreichbar machen.

Dafür bietet sich im internen Netz eine eigene lokale DNS-Adresse an, zum Beispiel:

status.home.arpa

In AdGuard Home legen wir später einen lokalen DNS-Eintrag beziehungsweise Rewrite an:

status.home.arpa → 192.168.178.10

Dann:

http://status.home.arpa {
    reverse_proxy uptime-kuma:3001
}

Warum:

uptime-kuma:3001

und nicht:

localhost:3001

?

Weil localhost innerhalb des Caddy-Containers Caddy selbst bedeutet.

Docker-Netzwerke lösen andere Services dagegen über ihren Servicenamen auf. Genau darauf weist auch die Caddy-Dokumentation hin.

Docker ist keine WG.

localhost ist nicht „irgendwer hier im Haus“.

Wichtig: Caddyfile geändert heißt nicht Caddy geändert

Jetzt einer der wichtigsten Punkte dieses Artikels.

Du änderst:

./caddy/conf/Caddyfile

und tippst danach:

docker compose up -d

Und?

Nichts.

Also: Die Datei ist im Container geändert.

Aber Caddy läuft weiterhin mit der bereits geladenen Konfiguration.

docker compose up -d sieht schließlich keinen Grund, einen unveränderten Container neu zu starten.

Das ist kein Caddy-Bug.

Das ist dein Computer, der exakt das tut, was du ihm gesagt hast.

Frechheit.

Nach einer Änderung der Caddyfile machen wir deshalb:

docker compose exec -w /etc/caddy caddy caddy reload

Das ist der von Caddy empfohlene Weg für Docker und lädt die Konfiguration ohne kompletten Neustart neu.

Und genau deshalb nicht einfach:

docker compose restart caddy

obwohl das natürlich ebenfalls funktionieren würde.

reload:

neue Konfiguration laden.

restart:

Caddy umbringen und neu starten.

Wenn ich meine Wohnzimmerlampe heller möchte, schalte ich auch nicht den Sicherungskasten aus.

Meistens.

Vor dem Reload kann man die Config sogar prüfen:

docker compose exec -w /etc/caddy caddy caddy validate --config /etc/caddy/Caddyfile

Und danach:

docker compose exec -w /etc/caddy caddy caddy reload

Erst prüfen. Dann laden.

Revolutionäre Betriebsführung Teil 2.

Und jetzt HTTPS – aber richtig

Hier wird es wichtig.

Caddy ist bekannt für:

HTTPS automatisch.

Und das stimmt.

Aber „automatisch“ bedeutet nicht:

Caddy kann die Gesetze des Internets außer Kraft setzen.

Wenn du in deine Caddyfile einfach schreibst:

192.168.178.10 {
    respond "Hallo"
}

versucht Caddy standardmäßig HTTPS bereitzustellen.

Bei einer privaten LAN-IP wie 192.168.178.10 bekommst du aber nicht plötzlich ein weltweit vertrauenswürdiges Let's-Encrypt-Zertifikat.

Caddy verwendet für lokale IP-Adressen und interne Namen eine eigene interne CA. Geräte, die dieser CA nicht vertrauen, zeigen entsprechend Zertifikatswarnungen.

Das gilt auch für:

status.home.arpa

.home.arpa ist bewusst für lokale Netze gedacht und qualifiziert nicht für ein normales öffentlich vertrauenswürdiges Zertifikat.

Wir haben also drei Möglichkeiten.

Möglichkeit 1: Intern einfach HTTP

Genau das machen wir in unserem Basis-Setup:

http://status.home.arpa {
    reverse_proxy uptime-kuma:3001
}

Innerhalb eines vertrauenswürdigen Heimnetzes ist das für den Einstieg einfach.

Aber:

HTTP ist nicht verschlüsselt.

Wer auch im lokalen Netz Verschlüsselung möchte, nimmt Variante 2 oder 3.

Möglichkeit 2: Internes HTTPS mit Caddys eigener CA

Dann:

status.home.arpa {
    tls internal
    reverse_proxy uptime-kuma:3001
}

Caddy erzeugt dafür selbst Zertifikate.

Kryptografisch vollkommen okay.

Das Problem sitzt nicht auf dem Server.

Das Problem sitzt im Browser:

„KENNE ICH NICHT!“

Damit Browser und Geräte das Zertifikat akzeptieren, muss Caddys Root-CA auf den jeweiligen Clients als vertrauenswürdig installiert werden.

Caddy weist ausdrücklich darauf hin, dass das bei Docker nicht automatisch auf allen Geräten passieren kann.

Das ist eine saubere Lösung.

Aber eben etwas mehr Arbeit.

Laptop.

Smartphone.

Tablet.

Vielleicht Fernseher.

Vielleicht der Toaster.

Je nachdem, was bei euch inzwischen Browser besitzt.

Möglichkeit 3: Echte Domain und öffentliches Zertifikat

Beispiel:

status.example.de

Dann kann Caddy automatisch ein öffentlich vertrauenswürdiges Zertifikat besorgen.

Dafür müssen aber die Voraussetzungen stimmen.

Die Domain muss korrekt auf deine öffentliche Adresse zeigen und Caddy muss für die normale HTTP-/TLS-Challenge von außen über Port 80 beziehungsweise 443 erreichbar sein. Im Heimnetz bedeutet das meist entsprechende Portweiterleitungen am Router.

Dann reicht beispielsweise:

status.example.de {
    reverse_proxy uptime-kuma:3001
}

Caddy kümmert sich um Zertifikat und Erneuerung.

Das ist wirklich angenehm.

Aber dadurch hast du einen Dienst nach außen geöffnet.

Das sollte eine Entscheidung sein.

Kein Nebeneffekt eines Tutorials.

Für nur intern erreichbare echte Domains gibt es zusätzlich DNS-01-Challenges. Dafür braucht Caddy allerdings passend zum DNS-Anbieter ein entsprechendes Modul beziehungsweise einen passenden Build.

Das ist Stoff für einen eigenen Artikel.

Hier gilt:

HTTP intern für den Einstieg.

Oder:

interne CA bewusst einrichten.

Oder:

öffentliche Domain bewusst veröffentlichen.

Nicht:

„Caddy macht HTTPS, wird schon irgendwie gehen.“

Das wäre technisch ungefähr auf Node64-Marketingniveau.

Uptime Kuma: Monitoring

Kuma läuft zunächst unter:

http://192.168.178.10:3001

Account einrichten.

Dann Monitore erstellen.

Website.

Ping.

TCP.

DNS.

Zertifikate.

Was tatsächlich überwacht werden soll.

Uptime Kuma 2 nutzt unter Docker /app/data für seine persistenten Daten. Die Entwickler warnen vor Dateisystemen ohne zuverlässige POSIX-Locks, beispielsweise problematischen NFS-Konfigurationen, weil dort die SQLite-Datenbank beschädigt werden kann.

Deshalb liegt:

./uptime-kuma

auf dem lokalen Datenträger.

Nicht:

NAS → WLAN → Repeater → NFS → SQLite → Gebet.

Und etwas fehlt bewusst:

/var/run/docker.sock

Ja.

Dann könnte Kuma direkt Container überwachen.

Aber der Docker-Socket ist mächtig.

Ich brauche keinen Webdienst mit weitreichendem Zugriff auf meinen Docker-Daemon, nur damit neben AdGuard Home noch ein hübsches grünes Kästchen erscheint.

Ich überwache lieber:

Funktioniert DNS?

statt:

Behauptet Docker, dass der Prozess noch lebt?

running ist schließlich kein Qualitätsmerkmal.

Windows ME war auch running.

AdGuard Home: DNS

AdGuard bekommt:

53/tcp
53/udp
3000/tcp

Port 53:

DNS.

Port 3000:

Einrichtung und in unserem Beispiel auch Verwaltung.

Die offizielle Dokumentation listet noch deutlich mehr Ports für DHCP, DoH, DoT, DoQ, DNSCrypt und Debugging auf. Wir brauchen sie nicht, also öffnen wir sie nicht.

Nicht benutzt = nicht veröffentlicht.

Security kann enttäuschend unspektakulär sein.

Erste Einrichtung:

http://192.168.178.10:3000

Im Setup lassen wir das Admin-Webinterface bewusst auf Port 3000.

Danach trägst du im Router oder auf einzelnen Geräten als DNS-Server ein:

192.168.178.10

Jetzt kannst du beispielsweise den lokalen Eintrag erstellen:

status.home.arpa → 192.168.178.10

Und schon funktioniert unser Caddy-Beispiel:

http://status.home.arpa

Kein externer Account.

Keine Cloud.

Kein DNS-Paket Deluxe Premium Home Enterprise.

Ein DNS-Eintrag.

Manchmal geht es wirklich.

Eine Einschränkung:

Im normalen Docker-Bridge-Modus kann AdGuard Home statt der ursprünglichen Client-IP unter Umständen nur eine Docker-Adresse sehen.

AdGuard empfiehlt Host-Networking, wenn die echten Client-IPs benötigt werden.

Machen wir hier nicht.

Denn dann kommen zusätzliche Portkonflikte und weniger Netzwerkisolation ins Spiel.

Für den einfachen Stack gilt:

Erst funktionieren. Dann optimieren.

Nicht:

„Wir bauen Version 1 direkt für die NATO.“

Falls Port 53 bereits belegt ist:

sudo ss -lntup | grep ':53'

Erst anschauen, wer da sitzt.

Dann entscheiden.

Nicht irgendeinen Systemdienst abschalten, weil Kevin auf Reddit geschrieben hat:

trust me bro

ddclient: DynDNS

Jetzt DynDNS.

Öffentliche IP ändert sich.

DNS soll folgen.

Dafür gibt es ddclient.

Nicht erst seit gestern.

Nicht als Revolution.

Einfach als Programm.

Unsere Datei:

./ddclient/ddclient.conf

Der LinuxServer-Container nutzt /config für seine persistenten Konfigurationsdateien. Änderungen an ddclient.conf werden vom Container automatisch neu eingelesen.

Die konkrete Konfiguration hängt vom DNS-Anbieter ab.

Zum Beispiel unterstützt ddclient Cloudflare, Hetzner, DigitalOcean, Gandi, Porkbun und zahlreiche klassische DynDNS-Dienste.

Bei Cloudflare sieht die aktuelle Konfiguration grundsätzlich beispielsweise so aus:

usev4=web

protocol=cloudflare
zone=example.de
password='DEIN_API_TOKEN'

home.example.de

ddclient empfiehlt dafür ein eingeschränktes API-Token statt des alten globalen API-Schlüssels.

Und jetzt kommt die eigentliche Schönheit:

Du wechselst deinen DynDNS-Anbieter?

Dann ändern wir:

ddclient.conf

Nicht Caddy.

Nicht AdGuard.

Nicht Kuma.

Nicht das komplette Homelab.

DynDNS hat sich geändert. Also ändern wir DynDNS.

Ich könnte mich daran gewöhnen.

Was bewusst fehlt

CrowdSec.

Honeypot.

WireGuard.

Grafana.

Prometheus.

Portainer.

Watchtower.

Homepage.

Guacamole.

Eine Blockchain.

KI.

Und ein Dashboard, das überwacht, ob das Monitoring-Dashboard erreichbar ist.

Absichtlich.

Denn wir wollten zeigen, dass typische Infrastrukturaufgaben mit getrennten Komponenten gelöst werden können.

Wenn du CrowdSec brauchst:

hinzufügen.

Wenn du WireGuard brauchst:

hinzufügen.

Wenn du einen Honeypot betreiben möchtest und weißt, warum:

hinzufügen.

Als eigenen Dienst.

Nicht:

„Wenn wir schon fünf Funktionen haben, bauen wir vorsichtshalber noch zwölf ein.“

Genau so entstehen die Produkte, über die wir uns anschließend lustig machen.

Updates und Backups

Unsere Daten:

./caddy/
./uptime-kuma/
./adguard/
./ddclient/

Das ist angenehm banal.

Backup machen.

Dann:

docker compose pull
docker compose up -d

Bei Uptime Kuma empfehlen die aktuellen Update-Hinweise mit Docker Compose ebenfalls, das neue Image zu ziehen und den Container neu zu erstellen.

Danach:

docker compose ps

Logs:

docker compose logs --tail=100

Wichtig:

Das gilt für neue Container-Images beziehungsweise Änderungen an Compose.

Nicht für eine geänderte Caddyfile.

Da waren wir ja inzwischen schlauer:

docker compose exec -w /etc/caddy caddy caddy validate --config /etc/caddy/Caddyfile
docker compose exec -w /etc/caddy caddy caddy reload

Man könnte das natürlich auch automatisieren.

Aber ich würde nicht blind jede Nacht sämtliche Infrastruktur auf latest ziehen und morgens schauen, ob das Haus noch DNS hat.

Changelog.

Backup.

Update.

Test.

Ja, das ist Arbeit.

Man nennt es Administration.

Warum das für mich die bessere Lösung ist

Jetzt nochmal zurück zu Node64.

Wir haben hier:

Caddy.

Kuma.

AdGuard.

ddclient.

Vier Container.

Vier Aufgaben.

Eine compose.yaml.

Und der große Vorteil ist nicht, dass diese vier Produkte von Gott persönlich ausgewählt wurden.

Gefällt mir Caddy nicht mehr?

Traefik.

nginx.

HAProxy.

Was auch immer.

Gefällt mir AdGuard nicht mehr?

Pi-hole.

Kuma nervt?

Anderes Monitoring.

ddclient passt nicht?

DynDNS-Funktion des Routers.

Oder anderer Client.

Austauschbar.

Das ist die eigentliche Architektur.

Nicht:

„Wir haben alles in einer Oberfläche.“

Das ist UI.

Architektur beginnt darunter.

Wenn mein Monitoring ein fehlerhaftes Update bekommt, möchte ich nicht gleichzeitig darüber nachdenken müssen, ob derselbe Prozess gerade meinen DNS-Server spielt.

Wenn mein Proxy ein Problem hat, soll mein DNS davon nichts wissen.

Wenn ich den DynDNS-Anbieter wechsle, möchte ich keine Infrastrukturplattform migrieren.

Langweilig.

Getrennt.

Vorhersehbar.

Geil.

Und Docker Compose erledigt bereits den Teil:

„Wie starte ich diese Programme gemeinsam?“

Dafür wurde es gebaut.

Wir müssen nicht erst wieder vier Programme zu einem zusammenkleben und anschließend stolz erklären:

Alles in einem Container!

Das ist ungefähr so, als würde man vier Zimmer bauen, anschließend alle Wände herausreißen und sagen:

Schaut mal, wie offen der Grundriss jetzt ist.

Ja.

Bis einer schnarcht.

Unser Stack ist nicht die einzig richtige Homelab-Konfiguration.

Natürlich nicht.

Aber er zeigt etwas ziemlich Banales:

Für Reverse Proxy, Monitoring, DNS und DynDNS braucht man keinen neuen Alles-Könner.

Man braucht:

einen Proxy,

ein Monitoring,

einen DNS-Server,

einen DynDNS-Client.

Und ein bisschen Verständnis dafür, was man gerade tut.

Auch HTTPS braucht dieses Verständnis.

Caddy ist clever.

Aber nicht magisch.

Docker ist praktisch.

Aber nicht automatisch sicher.

Und vier Container sind nicht kompliziert, nur weil irgendwo jemand beschlossen hat, dass ein Container hübscher aussieht.

Vier Container.

Vier Jobs.

Eine Datei.

Und wenn einer Mist baut:

fliegt der eine raus.

Das Rad ist nicht deshalb langweilig, weil es schon erfunden wurde.

Es ist rund, weil sich die Form verdammt gut bewährt hat.

✳ ENDE DER ÜBERTRAGUNG.
HAST DU SENF DAZU?Senf dazugeben ↗
DISKUSSION.EXE

Dein Senf ist gefragt.

0 Gespräche

Die Diskette ist eingelegt. Hier kommen eure Gedanken, Fragen und gepflegten Gegenreden – persönlich freigeschaltet.

Noch keine freigegebenen Kommentare. Der erste Beitrag ist noch frei!

✎ POSTAUSGANG.EXE ▢ ×

Dein Senf dazu

Du erhältst einen Bestätigungslink per E-Mail. Danach wird dein Kommentar persönlich moderiert.

🎲 RANDOM.EXE💾 1.44 MB PURE KRAM