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 namens proxy, 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 "proxy", aber ein "web" — ein
Bridge-Netz ohne Stack, also die uebliche Konvention fuer einen Reverse Proxy.
PROXY_NETWORK steht deshalb auf "web", 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
-offen sein.
+**A · Der Proxy hängt im selben Docker-Netz** — der sauberere Weg, kein Port
+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
-die Namen, `docker network inspect <name>` die Mitglieder.
-
-**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:
+**B · Der Proxy erreicht die Dienste über den Host** — so laufen Bot und Hub
+hier schon, mit `http://host.docker.internal:3080`.
 
 ```
-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
-`docker-compose.hostports.yml` erklärt.
+`host.docker.internal` das erreicht, hängt an der Docker-Fassung — in
+`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
-#   MinIO bleiben im internen Netz. Zum Ausprobieren gibt es
-#   docker-compose.local.yml — die macht es andersherum, und dort ist es
-#   richtig.
+#   Ein Weg nach aussen. Diese Datei allein ist von aussen NICHT erreichbar —
+#   das ist Absicht, denn wie der Reverse Proxy die Dienste findet,
+#   unterscheidet sich je Aufbau. Waehle eine Ergaenzung:
+#
+#     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]
-    # 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]
 
 networks:
   internal:
     driver: bridge
-  proxy:
-    # Das Netz, in dem der bestehende Reverse Proxy haengt.
-    name: ${PROXY_NETWORK:-proxy}
-    external: true
 
 volumes:
   db: