Ein Weg vom Quelltext in die Registry — und von dort aufs NAS

Damit das Image dort landet, wo das NAS es holen kann.

**`.gitea/workflows/image.yml`** — Gitea baut selbst. Bei jedem Push auf
`main` entsteht das Image für **beide** Architekturen und landet in der
Registry desselben Gitea. Niemand muss daran denken, niemand muss angemeldet
sein, und niemand kann die Architektur vergessen.

Voraussetzung ist ein registrierter Act-Runner. Hat deiner keinen, läuft die
Datei nie an — dafür gibt es den zweiten Weg.

**`Tools/image-veroeffentlichen.sh`** — ein Befehl vom Arbeitsrechner, baut
amd64 und arm64 und lädt hoch. Angemeldet wird einmalig von Hand; das
Passwort tippt nur, wer es kennt.

Beides legt `:latest` ab, dazu den Kurz-Hash und auf einem Git-Tag dessen
Namen — damit sich eine Fassung festnageln lässt, statt immer „latest" zu
ziehen.

Die Anleitung bekommt vier neue Abschnitte: Gitea baut selbst, von Hand
bauen, das Paket öffentlich stellen, und **die Registry im NAS eintragen** —
also genau der Dialog „Quellname des Images", mit Alias `gitea` und Link
`https://git.scarriffle.com/`. Für ein privates Paket ein Zugriffstoken mit
`read:package`, nicht das Kontopasswort: ein Token lässt sich einzeln
widerrufen.

Die Beispiel-Compose zeigte auf `ghcr.io/scarriffle/flaro` — dort liegt
nichts und lag nie etwas. Jetzt auf die Gitea-Registry.

---

**Ein Fehler im eigenen Skript, gefunden beim ersten Lauf.** Die Prüfung
„läuft Docker?" war `docker info | grep -q .` — und `grep -q` beendet die
Pipe beim ersten Treffer, Docker bekommt SIGPIPE, und mit `set -o pipefail`
gilt das als Fehlschlag. Das Skript meldete „Docker läuft nicht", während
Docker lief und gerade ein Image gebaut hatte.

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

docs/NAS-EINRICHTEN.md

@@ -49,38 +49,75 @@ Drei Wege. Der erste ist der bequemste, der zweite braucht keine Registry.
 Dein Gitea unter `git.scarriffle.com` bringt eine Container-Registry mit.
 Einmal einrichten, danach ist jedes Update ein `docker compose pull`.
 
-Auf dem Arbeitsrechner:
+#### A1 · Gitea baut selbst
+
+`.gitea/workflows/image.yml` liegt im Projekt. Bei jedem Push auf `main`
+baut Gitea das Image für **beide** Architekturen und legt es ab — ohne dass
+jemand daran denken muss, und ohne Anmeldung am Arbeitsrechner.
+
+**Voraussetzung ist ein registrierter Act-Runner.** Hat dein Gitea keinen,
+passiert nichts; dann gilt A2. Nachsehen unter
+*Einstellungen → Actions → Runner*. Ein Runner lässt sich als Container
+neben Gitea betreiben:
+
+```bash
+docker run -d --restart unless-stopped --name gitea-runner \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -e GITEA_INSTANCE_URL=https://git.scarriffle.com \
+    -e GITEA_RUNNER_REGISTRATION_TOKEN=<Token aus den Einstellungen> \
+    gitea/act_runner:latest
+```
+
+#### A2 · Von Hand vom Arbeitsrechner
+
+Einmalig anmelden — das Passwort tippst du selbst ein:
 
 ```bash
 docker login git.scarriffle.com
 ```
 
+Danach genügt ein Befehl; er baut amd64 **und** arm64 und lädt hoch:
+
 ```bash
-cd ~/Projects_Coding/Flixy
-docker buildx build --platform linux/amd64 \
-    -f server/Dockerfile \
-    -t git.scarriffle.com/scarriffle/flaro:latest \
-    --push .
+Tools/image-veroeffentlichen.sh
 ```
 
-`--push` lädt direkt hoch; ein getrenntes `docker push` entfällt.
+Mit einer Fassungsnummer, wenn du sie festnageln willst:
 
-Auf dem NAS dann in der Compose-Datei:
+```bash
+Tools/image-veroeffentlichen.sh 0.2.0
+```
+
+#### A3 · Das Paket öffentlich stellen
+
+Sonst muss sich auch das NAS anmelden. In Gitea unter
+*dein Profil → Pakete → flaro → Einstellungen* auf öffentlich stellen. Der
+Quelltext ist ohnehin offen; das Image enthält nichts, was er nicht auch
+enthält.
+
+#### A4 · Die Registry im NAS eintragen
+
+In der Docker-App des UGREEN: **Repository → Zahnrad → Quellname des
+Images → Hinzufügen**. Dort stehen schon DockerHub und `ghcr.io`; daneben
+kommt:
+
+| Feld | Wert |
+|---|---|
+| Alias | `gitea` |
+| Link | `https://git.scarriffle.com/` |
+
+**Bestätigen** — danach findet die Suche in der Docker-App auch
+`scarriffle/flaro`. Ist das Paket privat, trägst du unter
+*Registierungseinstellungen* Benutzername und ein Gitea-Zugriffstoken ein
+(nicht dein Kontopasswort: ein Token lässt sich einzeln widerrufen, unter
+*Einstellungen → Anwendungen → Zugriffstoken*, Berechtigung `read:package`).
+
+In der Compose-Datei steht dann:
 
 ```yaml
 image: git.scarriffle.com/scarriffle/flaro:latest
 ```
 
-Ist das Paket in Gitea **privat**, muss sich auch das NAS anmelden:
-
-```bash
-docker login git.scarriffle.com
-```
-
-Einfacher ist, das Paket in Gitea auf öffentlich zu stellen — unter
-*Pakete → flaro → Einstellungen*. Der Quelltext ist ohnehin offen; das Image
-enthält nichts, was es nicht auch tut.
-
 ### Weg B — als Datei hochladen
 
 Ohne Registry, dafür bei jedem Update von Hand.