Image vydávat z GitHubu, doma ho jen zkoušet

Domácí runner běží v LXC. binfmt_misc je vlastnost jádra hostitele a do toho
se kvůli počitadlu kostek vrtat nebude — je produkční. tonistiigi/binfmt sice
hlásil úspěch, ale na hostiteli po něm nezůstala žádná registrace, takže
buildkit arm64 mezi platformami nikdy neuvidí.

Stejná dělba jako u binárek: doma se hlídá, na GitHubu se vydává. Zdejší
workflow staví nativní amd64 obyčejným `docker build` a zkouší ho spustit nad
každým pull requestem; žádný buildx, žádná emulace, nic, co by na runneru
mohlo chybět. Publikaci multiarch image převzalo .github/workflows/image.yml,
kde jsou běhouni plnohodnotné virtuály a emulace funguje bez zásahu.

Publikovat jde nově jen z tagu. Ruční spuštění nad větví by udělalo `:latest`
ukazující na rozdělanou práci.

.gitea/workflows/image.yml

@@ -1,23 +1,21 @@
-# Postaví kontejnerový image a při vydání ho pošle do registru Gitey.
+# Postaví kontejnerový image a zkusí ho spustit. Nikam ho neposílá.
 #
-# Runner běží v host módu, takže tu nejsou hotové akce z marketplace a všechno
-# je obyčejný shell — stejně jako v ostatních workflow tady. Docker na
-# hostiteli být musí, ten se tu neinstaluje.
+# Dockerfile by se jinak rozbil až ve chvíli, kdy se tagne release — tohle ho
+# ohlídá nad každým pull requestem.
 #
-# Nad pull requesty se image staví a zkouší, ale nikam se neposílá. Dockerfile
-# by se jinak rozbil až ve chvíli, kdy se tagne release.
+# Publikuje se jinde: .github/workflows/image.yml. Zdejší runner běží v LXC,
+# kde nejde zaregistrovat binfmt, takže arm64 by se tu postavit nedalo.
+# Registrace je vlastnost jádra hostitele a to je produkční stroj, do kterého
+# se kvůli počitadlu kostek vrtat nebude.
+#
+# Staví se nativní amd64 obyčejným `docker build`, žádný buildx ani emulace.
 name: image
 
 on:
-  push:
-    tags: ["v*"]
   pull_request:
   workflow_dispatch:
 
 env:
-  REGISTRY: gitea.spacilovi.eu
-  IMAGE: david-spacil/dice-counter
-  PLATFORMS: linux/amd64,linux/arm64
   ZKOUSKA_PORT: "18000"
 
 jobs:
@@ -42,53 +40,21 @@ jobs:
         run: |
           command -v docker >/dev/null \
               || { echo "Docker na runneru není." >&2; exit 1; }
-          docker buildx version >/dev/null 2>&1 \
-              || { echo "Chybí docker buildx — bez něj multiarch nejde." >&2; exit 1; }
           docker version --format '{{.Server.Version}}'
 
-      - name: QEMU pro cizí architektury
+      - name: Stavba
         run: |
-          # Registruje binfmt, aby šlo na x86 stroji stavět i arm64. Všechny
-          # závislosti jsou čistě pythonní, takže se pod emulací nic
-          # nekompiluje a stavba tím prakticky netrpí.
-          docker run --privileged --rm tonistiigi/binfmt --install arm64
-
-      - name: Builder
-        run: |
-          # Výchozí ovladač Dockeru multiplatformní stavbu neumí, je potřeba
-          # docker-container. Staví se pokaždé načisto — builder z minulého
-          # běhu by si pamatoval platformy z doby před registrací emulace.
-          #
-          # Bez roury do `head`: pod pipefail by zavřená roura shodila celý
-          # krok dřív, než docker dopíše výstup.
-          docker buildx rm kostky >/dev/null 2>&1 || true
-          docker buildx create --name kostky --driver docker-container --use
-          docker buildx inspect --bootstrap
-
-          # Kdyby arm64 v seznamu chybělo, stavba spadne až na konci a hláška
-          # nic neřekne. Radši to zkontrolujeme hned.
-          PLATFORMY=$(docker buildx inspect)
-          echo "$PLATFORMY" | grep -q "linux/arm64" || {
-              echo "Buildkit nevidí linux/arm64, i když se binfmt nainstaloval." >&2
-              echo "Emulace musí být registrovaná s příznakem F, jinak si na ni" >&2
-              echo "buildkit ze svého kontejneru nesáhne. Na runneru to natrvalo" >&2
-              echo "vyřeší balíček qemu-user-static." >&2
-              echo "--- současná registrace ---" >&2
-              cat /proc/sys/fs/binfmt_misc/qemu-aarch64 >&2 2>/dev/null || echo "(žádná)" >&2
-              exit 1; }
-
-      - name: Zkouška
-        run: |
-          # Zkouší se nativní amd64: --load umí do místního Dockeru uložit jen
-          # jednu platformu a spustit stejně nic jiného nejde.
-          docker buildx build --platform linux/amd64 --load \
-              -f deploy/Dockerfile \
+          docker build -f deploy/Dockerfile \
               --build-arg VERSION="zkouska-${GITHUB_SHA:0:7}" \
               -t kostky:zkouska .
 
+      - name: Zkouška
+        run: |
           trap 'docker rm -f kostky-zkouska >/dev/null 2>&1 || true' EXIT
 
-          # Adresa se vnucuje, ať zkouška nezávisí na síti běhounu a dá se
+          # Port musí být stejný uvnitř i venku: appka poslouchá na DICE_PORT,
+          # takže mapovat ho na jiný by znamenalo mířit do prázdna.
+          # Adresa se vnucuje, ať zkouška nezávisí na síti runneru a dá se
           # ověřit, co přesně tabule nabídne.
           docker run -d --name kostky-zkouska --init \
               -p "${ZKOUSKA_PORT}:${ZKOUSKA_PORT}" -e DICE_HOST=127.0.0.1 \
@@ -114,29 +80,6 @@ jobs:
           docker logs kostky-zkouska
           echo "Image jede."
 
-      - name: Publikace
-        if: startsWith(github.ref, 'refs/tags/')
-        env:
-          TOKEN: ${{ secrets.PACKAGE_TOKEN }}
-          VLASTNIK: ${{ github.repository_owner }}
-        run: |
-          # Automatický token Actions na balíčky nestačí — Gitea to zatím
-          # neumí a sama v dokumentaci odkazuje na osobní token. Ten je
-          # v secrets pod PACKAGE_TOKEN; jméno nesmí začínat na GITEA_,
-          # ten prefix si Gitea vyhrazuje.
-          [ -n "$TOKEN" ] || { echo "Chybí secret PACKAGE_TOKEN." >&2; exit 1; }
-          echo "$TOKEN" | docker login "$REGISTRY" -u "$VLASTNIK" --password-stdin
-          trap 'docker logout "$REGISTRY" >/dev/null 2>&1 || true' EXIT
-
-          # Značka bez počátečního "v": v repozitáři je v1.2.0, u image se
-          # čekají 1.2.0.
-          VERZE="${GITHUB_REF_NAME#v}"
-
-          docker buildx build --platform "$PLATFORMS" --push \
-              -f deploy/Dockerfile \
-              --build-arg VERSION="${GITHUB_REF_NAME}" \
-              -t "$REGISTRY/$IMAGE:$VERZE" \
-              -t "$REGISTRY/$IMAGE:latest" .
-
-          echo "Publikováno: $REGISTRY/$IMAGE:$VERZE a :latest"
-          docker buildx imagetools inspect "$REGISTRY/$IMAGE:$VERZE"
+      - name: Úklid
+        if: always()
+        run: docker rmi kostky:zkouska >/dev/null 2>&1 || true

.github/workflows/image.yml

@@ -0,0 +1,79 @@
+# Publikuje kontejnerový image do registru balíčků Gitey, pro amd64 i arm64.
+#
+# Proč zrovna odsud: domácí runner běží v LXC, kde nejde zaregistrovat binfmt
+# — je to vlastnost jádra hostitele a ten je produkční. Běhouni GitHubu jsou
+# plnohodnotné virtuály, kde emulace funguje bez řečí.
+#
+# Doma se image přesto staví a zkouší nad každým pull requestem
+# (.gitea/workflows/image.yml), jen se nikam neposílá. Stejná dělba jako
+# u binárek: doma se hlídá, tady se vydává.
+name: image
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+env:
+  REGISTRY: gitea.spacilovi.eu
+  IMAGE: david-spacil/dice-counter
+  PLATFORMS: linux/amd64,linux/arm64
+
+jobs:
+  publikace:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Přesná verze, ne plovoucí značka — viz binarky.yml.
+      - uses: actions/checkout@v7.0.1
+
+      - name: QEMU pro arm64
+        run: |
+          # Bez hotové akce z marketplace, ať není co udržovat. Běhoun je
+          # virtuál, takže privilegovaný kontejner smí zapisovat do binfmt
+          # a registrace platí pro celé jádro.
+          docker run --privileged --rm tonistiigi/binfmt --install arm64
+
+      - name: Builder
+        run: |
+          # Výchozí ovladač Dockeru multiplatformní stavbu neumí.
+          docker buildx create --name kostky --driver docker-container --use
+          docker buildx inspect --bootstrap
+
+          # Bez tohohle by stavba spadla až na konci a hláška by nic neřekla.
+          PLATFORMY=$(docker buildx inspect)
+          echo "$PLATFORMY" | grep -q "linux/arm64" || {
+              echo "Buildkit nevidí linux/arm64, emulace se nezaregistrovala." >&2
+              exit 1; }
+
+      - name: Publikace
+        env:
+          TOKEN: ${{ secrets.PACKAGE_TOKEN }}
+          # Uživatel v Gitee, ne na GitHubu. Shodou okolností je to totéž.
+          VLASTNIK: david-spacil
+        run: |
+          # Spouští se to i ručně, a to klidně nad větví. Bez tagu není z čeho
+          # udělat verzi a `:latest` by ukazoval na rozdělanou práci.
+          [ "$GITHUB_REF_TYPE" = tag ] || {
+              echo "Publikovat jde jen z tagu, tohle je ${GITHUB_REF_TYPE} ${GITHUB_REF_NAME}." >&2
+              exit 1; }
+
+          # Automatický token na balíčky nestačí ani u Gitey samotné, natož
+          # odsud — musí to být osobní token s oprávněním write:package.
+          [ -n "$TOKEN" ] || { echo "Chybí secret PACKAGE_TOKEN." >&2; exit 1; }
+          echo "$TOKEN" | docker login "$REGISTRY" -u "$VLASTNIK" --password-stdin
+          trap 'docker logout "$REGISTRY" >/dev/null 2>&1 || true' EXIT
+
+          # Značka bez počátečního "v": v repozitáři je v1.2.0, u image se
+          # čeká 1.2.0. Verze vypálená do image ale zůstává s "v", ať --version
+          # hlásí totéž co binárky.
+          VERZE="${GITHUB_REF_NAME#v}"
+
+          docker buildx build --platform "$PLATFORMS" --push \
+              -f deploy/Dockerfile \
+              --build-arg VERSION="${GITHUB_REF_NAME}" \
+              -t "$REGISTRY/$IMAGE:$VERZE" \
+              -t "$REGISTRY/$IMAGE:latest" .
+
+          echo "Publikováno: $REGISTRY/$IMAGE:$VERZE a :latest"
+          docker buildx imagetools inspect "$REGISTRY/$IMAGE:$VERZE"

README.md

@@ -263,7 +263,7 @@ při remíze na prvním místě se hraje dál.
 | `console.py` | aby čeština prošla i windowsovou konzolí |
 | `version.py` | která verze to je — z gitu, nebo z binárky |
 | `build.sh`, `kostky.spec` | stavba binárky |
-| `.gitea/workflows/` | testy, linuxová binárka a image doma |
+| `.gitea/workflows/` | testy, linuxová binárka a zkouška image doma |
 | `.github/workflows/` | binárky pro Windows a macOS |
 | `deploy/` | nasazení na server: Proxmox LXC a Docker |
 
@@ -345,8 +345,8 @@ Otagovaný commit spustí stavbu na obou stranách:
 | Kde | Co staví | Workflow |
 |---|---|---|
 | vlastní runner u Gitey | Linux x86-64 | `.gitea/workflows/binarka.yml` |
-| vlastní runner u Gitey | image amd64 + arm64 | `.gitea/workflows/image.yml` |
 | GitHub Actions | Windows, macOS ×2, Linux ARM64 | `.github/workflows/binarky.yml` |
+| GitHub Actions | image amd64 + arm64 | `.github/workflows/image.yml` |
 
 ```bash
 git tag v1.0.0 && git push origin v1.0.0
@@ -369,7 +369,14 @@ ověřit:
 sha256sum -c kostky-linux-x86_64.sha256     # na macOS: shasum -a 256 -c
 ```
 
-Nad pull requesty se Linux staví taky, jen se nikam nevěší.
+Nad pull requesty se Linux staví taky, jen se nikam nevěší. Totéž platí pro
+kontejnerový image — doma se nad každým PR postaví a zkusí nastartovat
+(`.gitea/workflows/image.yml`), publikuje se ale až z tagu na GitHubu.
+
+Image se schválně nevydává doma: tamní runner běží v LXC, kde nejde
+zaregistrovat emulaci pro arm64 — je to vlastnost jádra hostitele a ten je
+produkční stroj. Běhouni GitHubu jsou plnohodnotné virtuály, kde to funguje
+bez zásahu do čehokoli.
 
 ## Testy