fix: das externe Netz war fest verdrahtet und existierte nicht

'network proxy declared as external, but could not be found'.

Die Hauptdatei verlangte ein externes Netz , das es auf diesem Server
gar nicht gibt — und die Ergaenzung fuer host.docker.internal half nicht, weil
die Basis es trotzdem forderte. Das war die falsche Reihenfolge: der Weg nach
aussen ist gerade das, was sich je Aufbau unterscheidet, und gehoert damit
nicht in die Basis.

Jetzt ist docker-compose.yml neutral — von aussen nicht erreichbar, und das
ausdruecklich. Dazu waehlt man eine von zwei Ergaenzungen:

  docker-compose.proxynet.yml    Proxy haengt im selben Netz (http://minio:9000)
  docker-compose.hostports.yml   Proxy geht ueber den Host

Die Netzliste dieses Servers zeigt kein , aber ein  — ein
Bridge-Netz ohne Stack, also die uebliche Konvention fuer einen Reverse Proxy.
PROXY_NETWORK steht deshalb auf , mit dem Hinweis, es nachzusehen statt zu
glauben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.env.example

@@ -21,4 +21,11 @@ ADMIN_PASSWORD=
 PUBLIC_URL=https://fivecdn.d4rkst3r.de
 
 # Das Docker-Netz, in dem der bestehende Reverse Proxy haengt.
-PROXY_NETWORK=proxy
+#
+# Wird NUR gebraucht, wenn du docker-compose.proxynet.yml dazunimmst. Beim Weg
+# ueber host.docker.internal (docker-compose.hostports.yml) ist es
+# gegenstandslos.
+#
+# `docker network ls` zeigt die Namen. Auf diesem Server heisst es
+# wahrscheinlich `web` — ein Bridge-Netz ohne Stack.
+PROXY_NETWORK=web

README.md

@@ -44,25 +44,39 @@ Die Werte gehören **in die Stack-Variablen**, nicht in eine Datei im Repo.
 
 ### Wie der Reverse Proxy die Dienste erreicht
 
-Zwei Wege, und welcher gilt, hängt daran, wie dein NPM aufgesetzt ist.
+`docker-compose.yml` allein ist von außen **nicht erreichbar** — das ist
+Absicht. Wie der Proxy die Dienste findet, hängt am Aufbau, also wählst du eine
+Ergänzung dazu. In Portainer beide Pfade unter *Compose path*, mit Komma:
 
-**A · NPM hängt im selben Docker-Netz** — der saubere Weg. Kein Port muss
+**A · Der Proxy hängt im selben Docker-Netz** — der sauberere Weg, kein Port
-offen sein.
+muss offen sein.
+
+```
+docker-compose.yml,docker-compose.proxynet.yml
+```
+
+Dazu `PROXY_NETWORK` auf den Namen des Netzes setzen, in dem der Proxy hängt.
+Welches das ist, zeigt Portainer unter *Networks* oder:
+
+```bash
+docker network ls
+docker network inspect <name>      # zeigt die Mitglieder
+```
+
+Auf diesem Server heißt es aller Wahrscheinlichkeit nach **`web`** — ein
+Bridge-Netz ohne Stack. Nachsehen lohnt trotzdem: steht der Proxy nicht drin,
+ist es der falsche Weg.
 
 ```
 fivecdn.d4rkst3r.de  ->  http://minio:9000
 <oberfläche>         ->  http://lite:8080
 ```
 
-Dafür muss NPM im Netz aus `PROXY_NETWORK` hängen. `docker network ls` zeigt
+**B · Der Proxy erreicht die Dienste über den Host** — so laufen Bot und Hub
-die Namen, `docker network inspect <name>` die Mitglieder.
+hier schon, mit `http://host.docker.internal:3080`.
-
-**B · NPM erreicht die Dienste über den Host** — so laufen Bot und Hub hier
-schon, mit `http://host.docker.internal:3080`. Dann braucht es offene Ports,
-und dafür gibt es die Ergänzung:
 
 ```
-Compose path:  docker-compose.yml,docker-compose.hostports.yml
+docker-compose.yml,docker-compose.hostports.yml
 ```
 
 ```
@@ -71,8 +85,8 @@ fivecdn.d4rkst3r.de  ->  http://host.docker.internal:9000
 ```
 
 Die Ports sind an `127.0.0.1` gebunden, also vom Internet aus zu. Ob
-`host.docker.internal` das erreicht, hängt an der Docker-Fassung — steht in
+`host.docker.internal` das erreicht, hängt an der Docker-Fassung — in
-`docker-compose.hostports.yml` erklärt.
+`docker-compose.hostports.yml` steht, was dann zu tun ist.
 
 ---
 
@@ -85,7 +99,7 @@ kommt später und woanders her: aus der laufenden Lite-Oberfläche.
 
 ```powershell
 function New-Secret([int]$n){ $b = New-Object byte[] $n; [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($b); ($b | ForEach-Object { $_.ToString('x2') }) -join '' }
-@("DB_PASSWORD=$(New-Secret 16)","MINIO_ROOT_PASSWORD=$(New-Secret 16)","API_TOKEN_HMAC_SECRET=$(New-Secret 32)","ADMIN_PASSWORD=$(New-Secret 12)","PUBLIC_URL=https://fivecdn.d4rkst3r.de","PROXY_NETWORK=proxy") | Set-Content -Encoding ascii .env
+@("DB_PASSWORD=$(New-Secret 16)","MINIO_ROOT_PASSWORD=$(New-Secret 16)","API_TOKEN_HMAC_SECRET=$(New-Secret 32)","ADMIN_PASSWORD=$(New-Secret 12)","PUBLIC_URL=https://fivecdn.d4rkst3r.de","PROXY_NETWORK=web") | Set-Content -Encoding ascii .env
 ```
 
 Zwei Fallen stecken darin, beide schon hineingetreten:

docker-compose.proxynet.yml

@@ -0,0 +1,35 @@
+# Ergaenzung fuer einen Reverse Proxy, der IM SELBEN Docker-Netz haengt.
+#
+# Der sauberere der beiden Wege: kein Port muss auf dem Host offen sein, der
+# Proxy spricht die Container direkt an.
+#
+#   docker compose -f docker-compose.yml -f docker-compose.proxynet.yml up -d
+#
+# In Portainer unter "Compose path", durch Komma getrennt:
+#   docker-compose.yml,docker-compose.proxynet.yml
+#
+# VORAUSSETZUNG: das Netz muss es schon geben, und der Proxy muss darin
+# haengen. Nachsehen:
+#
+#   docker network ls
+#   docker network inspect <name>       zeigt die Mitglieder
+#
+# Haengt der Proxy nirgends mit drin, ist das hier der falsche Weg — dann
+# docker-compose.hostports.yml nehmen. Ein Netz anzulegen, in dem nur diese
+# Container sitzen, bringt nichts: der Proxy muesste mit hinein.
+#
+# Danach in NPM:
+#   fivecdn.d4rkst3r.de  ->  http://minio:9000
+#   <oberflaeche>        ->  http://lite:8080
+
+services:
+  minio:
+    networks: [internal, proxy]
+
+  lite:
+    networks: [internal, proxy]
+
+networks:
+  proxy:
+    name: ${PROXY_NETWORK:-proxy}
+    external: true

docker-compose.yml

@@ -12,10 +12,17 @@
 #   das Ablegen von Bildern braucht es sie nicht, und ClickHouse ist eine
 #   schwere Abhaengigkeit. Nachruesten geht spaeter.
 #
-#   Offene Ports. Nur der Reverse Proxy spricht mit der App; Datenbank und
+#   Ein Weg nach aussen. Diese Datei allein ist von aussen NICHT erreichbar —
-#   MinIO bleiben im internen Netz. Zum Ausprobieren gibt es
+#   das ist Absicht, denn wie der Reverse Proxy die Dienste findet,
-#   docker-compose.local.yml — die macht es andersherum, und dort ist es
+#   unterscheidet sich je Aufbau. Waehle eine Ergaenzung:
-#   richtig.
+#
+#     docker-compose.hostports.yml   Proxy erreicht die Dienste ueber den Host
+#                                    (http://host.docker.internal:9000)
+#     docker-compose.proxynet.yml    Proxy haengt im selben Docker-Netz
+#                                    (http://minio:9000) — der sauberere Weg
+#
+#   In Portainer beide Pfade angeben, durch Komma getrennt:
+#     docker-compose.yml,docker-compose.hostports.yml
 
 services:
   db:
@@ -47,7 +54,7 @@ services:
       MINIO_SERVER_URL: ${PUBLIC_URL:?bitte setzen}
     volumes:
       - minio:/data
-    networks: [internal, proxy]
+    networks: [internal]
     healthcheck:
       test: ["CMD", "mc", "ready", "local"]
       interval: 10s
@@ -99,17 +106,11 @@ services:
       AWS_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:?bitte setzen}
       AWS_BUCKET: media
       AWS_REGION: auto
-    networks: [internal, proxy]
+    networks: [internal]
-    # KEIN ports: — der Reverse Proxy erreicht die App ueber das Netz `proxy`.
-    # Wer hier 8080 aufmacht, hat die Oberflaeche ohne TLS im Internet.
 
 networks:
   internal:
     driver: bridge
-  proxy:
-    # Das Netz, in dem der bestehende Reverse Proxy haengt.
-    name: ${PROXY_NETWORK:-proxy}
-    external: true
 
 volumes:
   db: