name: Publish image # Fires on the version tag release-please creates when the release PR is # merged (vX.Y.Z, plain tags - see OKF_Nuxt/decisions/release-engineering.md). # A push to main does NOT build: an image tag always maps to a released # version, so what runs in the cluster is traceable to a release, not to an # arbitrary commit. on: push: tags: - 'v*' # Manual rehearsal from the Gitea UI (Actions -> Publish image -> Run # workflow). `push` defaults to false: the job builds and smoke-tests, then # stops without publishing, so the runner can be verified without creating # a tag or a package version. Set `push` to true (and `latest` only for a # real release) to publish. workflow_dispatch: inputs: version: description: 'Version to build, e.g. v0.0.1 (vMAJOR.MINOR.PATCH)' required: true push: description: 'Push the image to the registry' required: false default: 'false' latest: description: 'Also move :latest (real releases only)' required: false default: 'false' # The runner has capacity 1, so releases already serialize. This keeps a # manual re-run from racing a fresh release on the same tags. concurrency: group: publish-image cancel-in-progress: false env: # Registry host + repository path. The path segment is the Gitea # organisation, so k3s pulls git.noelsabia.dev/cv_website/nuxt:. IMAGE: git.noelsabia.dev/cv_website/nuxt APP_DIR: . jobs: publish: name: Build and push image # Dedicated label, NOT ubuntu-latest: this job needs the host Docker # socket, and `docker_host` is a runner-wide setting. Sharing a label # with pr-checker.yml would hand PR code (from a branch) a root- # equivalent socket on the host that also runs Gitea and k3s. # Register a second act_runner with `--labels publish:docker://node:22-bookworm` # and `container.docker_host: automount` in its config, before the first # tag: an unmatched label leaves the job queued indefinitely. runs-on: publish # A hung build would hold the capacity-1 runner and, through it, every # other job on this server. Gitea's instance default is not a contract. timeout-minutes: 20 # Same base image as the other jobs. The build runs on the runner's # Docker daemon (not in a nested daemon), so this container only needs # the CLI - see OKF_Nuxt/decisions/registry-publishing.md. container: node:22-bookworm steps: - uses: actions/checkout@v4 - name: Install Docker CLI # Debian's docker.io, not a curl-piped binary from GitHub: apt is a # signed channel, and bookworm ships an arm64 build. Only the client # is needed; the daemon lives on the host. run: | apt-get update apt-get install -y --no-install-recommends docker.io docker --version - name: Check daemon access # Fail here, with the cause, instead of halfway through a build. # An unreachable daemon means the runner was started without the # host socket mounted: set `docker_host: automount` in the # act_runner config and restart the service. # # The socket is root-equivalent on the host, and automount is a # runner-wide setting - it applies to every job on that runner, # including PR jobs. Only enable it on a runner label that # PR-triggered jobs cannot use; see the trust boundary in # OKF_Nuxt/decisions/registry-publishing.md. run: | echo "DOCKER_HOST=${DOCKER_HOST:-}" if ! docker info > /dev/null 2>&1; then echo "::error::no Docker daemon reachable from this job - the act_runner needs the host Docker socket (docker_host: automount)" exit 1 fi - name: Resolve version and tags id: version env: # Inputs go through env, not direct interpolation: a value pasted # into a `run:` block is shell code before any check can run. INPUT_VERSION: ${{ github.event.inputs.version }} INPUT_LATEST: ${{ github.event.inputs.latest }} run: | # On a tag push GITHUB_REF_NAME is the tag; on workflow_dispatch it # is the BRANCH, so the manual version input must win. The git # fallback keeps tag pushes working if a runner omits the variable. version="$INPUT_VERSION" if [ -z "$version" ]; then version="${GITHUB_REF_NAME:-$(git describe --tags --exact-match HEAD)}" fi # Strict semver, not a `v[0-9]*` prefix match: that would accept # `v1`, `v1-anything` and prereleases, all valid registry tags. if ! printf '%s' "$version" | grep -qE '^v[0-9]+\.[0-9]+\.[0-9]+$'; then echo "::error::expected a vMAJOR.MINOR.PATCH tag, got '${version}'" exit 1 fi sha="$(git rev-parse --short=12 HEAD)" # `latest` follows the newest release, not the newest build. A # re-run of an older tag (Gitea can replay any run) must not drag # `latest` backwards, while a re-run of the newest tag may set it: # that release had not produced an image yet. # A tag comparison needs the other tags, which a depth-1 tag # checkout does not have. If the fetch fails, skip `latest` and # say so - a wrong tag is worse than a missing one. # # A manual run moves `latest` only when the `latest` input says so; # a rehearsal must never repoint the production tag. if [ "$INPUT_LATEST" = "true" ]; then latest=true echo "manual run requested :latest" elif git fetch --tags --force --quiet origin 2>/dev/null; then newest="$(git tag -l | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 1)" if [ "$version" = "$newest" ]; then latest=true else latest=false echo "::warning::${version} is not the newest release (${newest}) - not moving :latest" fi else latest=false echo "::warning::could not list tags - not moving :latest" fi # Short SHA tag alongside the version: OKF_CV_Website/architecture/ # delivery.md asks for SHA-tagged images so every deploy is # traceable to a commit even after a tag is moved. { echo "version=${version}" echo "sha=${sha}" echo "latest=${latest}" } >> "$GITHUB_OUTPUT" echo "Building ${version} from ${sha} (latest: ${latest})" - name: Log in to the registry env: REGISTRY_USERNAME: ${{ secrets.REGISTRY_USERNAME }} REGISTRY_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }} run: | # Missing secrets must fail loudly: an anonymous `docker push` # would answer 401 with a message most people misread as a # missing repository. [ -n "$REGISTRY_USERNAME" ] || { echo "::error::secret REGISTRY_USERNAME is empty"; exit 1; } [ -n "$REGISTRY_PASSWORD" ] || { echo "::error::secret REGISTRY_PASSWORD is empty"; exit 1; } printf '%s' "$REGISTRY_PASSWORD" \ | docker login git.noelsabia.dev -u "$REGISTRY_USERNAME" --password-stdin - name: Refuse to overwrite a published version # Build-only rehearsals publish nothing, so an existing tag is not a # conflict there; the guard only protects actual pushes. if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.push == 'true' }} env: REGISTRY_USERNAME: ${{ secrets.REGISTRY_USERNAME }} REGISTRY_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }} VERSION: ${{ steps.version.outputs.version }} run: | # A version tag is immutable once published. Gitea can replay any # run, and `docker push` would silently replace :vX.Y.Z with a # rebuilt image, so the release would change content after the # fact. A missing tag (first attempt, or a run that failed before # pushing) is fine - nothing was published. # # Registry v2 API instead of `docker manifest inspect`: the # Debian 20.10 client fails that command on OCI indexes with # "unsupported manifest media type and no default available", # for existing and missing tags alike. url="https://git.noelsabia.dev/v2/cv_website/nuxt/manifests/${VERSION}" code=$(curl -s -o /dev/null -w '%{http_code}' \ -u "${REGISTRY_USERNAME}:${REGISTRY_PASSWORD}" \ -H 'Accept: application/vnd.docker.distribution.manifest.v2+json' \ -H 'Accept: application/vnd.oci.image.index.v1+json' \ -H 'Accept: application/vnd.oci.image.manifest.v1+json' \ "$url") echo "GET /v2/cv_website/nuxt/manifests/${VERSION}: HTTP ${code}" case "$code" in 200) echo "::error::${VERSION} is already published and version tags are immutable - delete that tag in the registry deliberately to replace it"; exit 1 ;; 404) echo "${VERSION} is not published yet - continuing" ;; 401|403) echo "::error::registry rejected the credentials (HTTP ${code}) - check REGISTRY_USERNAME/REGISTRY_PASSWORD"; exit 1 ;; *) echo "::error::unexpected answer from the registry (HTTP ${code})"; exit 1 ;; esac - name: Build image env: VERSION: ${{ steps.version.outputs.version }} SHA: ${{ steps.version.outputs.sha }} run: | # --platform is explicit so a build on the wrong architecture fails # instead of silently producing an amd64 image the arm64 node # cannot run. Native here, no QEMU involved. docker build \ --platform linux/arm64 \ --label "org.opencontainers.image.version=${VERSION}" \ --label "org.opencontainers.image.revision=${SHA}" \ -t "${IMAGE}:${VERSION}" \ -t "${IMAGE}:sha-${SHA}" \ "${APP_DIR}" - name: Smoke-test the image env: VERSION: ${{ steps.version.outputs.version }} run: | # Start the real server inside the built image and require a 2xx # with a real SSR body, not an empty shell. Cheaper than # publishing a broken release, and the only step that proves the # Nitro output actually runs. Done inside the container because # the app's port is not reachable from this job container - the # daemon publishes on the host, not here. # # The size floor is deliberately loose: the rendered homepage was # 97 kB on 2026-10-24, so 10 kB catches "200 but nothing rendered" # without failing on a future copy change. docker run --rm "${IMAGE}:${VERSION}" sh -c ' node .output/server/index.mjs & server=$! i=0 while [ "$i" -lt 30 ]; do if out=$(node -e "fetch(\"http://127.0.0.1:3000/\").then(async r => { const body = await r.text(); if (!r.ok || body.length < 10000) process.exit(1); console.log(r.status + \" \" + body.length + \" bytes\") }).catch(() => process.exit(1))" 2>/dev/null); then echo "homepage rendered after ${i}s: HTTP ${out}" kill "$server" exit 0 fi i=$((i + 1)) sleep 1 done echo "no 2xx homepage with a rendered body within 30s" kill "$server" exit 1 ' - name: Tag latest if: steps.version.outputs.latest == 'true' env: VERSION: ${{ steps.version.outputs.version }} run: docker tag "${IMAGE}:${VERSION}" "${IMAGE}:latest" - name: Push image # Manual run with `push` left at false: build and smoke test only. if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.push == 'true' }} env: VERSION: ${{ steps.version.outputs.version }} SHA: ${{ steps.version.outputs.sha }} LATEST: ${{ steps.version.outputs.latest }} run: | # Explicit per tag, not `--all-tags`: --all-tags would also push # stale local tags left on the shared daemon by earlier runs. docker push "${IMAGE}:${VERSION}" docker push "${IMAGE}:sha-${SHA}" if [ "$LATEST" = "true" ]; then docker push "${IMAGE}:latest" echo "Pushed ${IMAGE}:${VERSION}, :sha-${SHA}, :latest" else echo "Pushed ${IMAGE}:${VERSION}, :sha-${SHA} (:latest untouched)" fi - name: Rehearsal summary if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.push != 'true' }} env: VERSION: ${{ steps.version.outputs.version }} SHA: ${{ steps.version.outputs.sha }} run: | echo "Build-only rehearsal for ${VERSION} (${SHA}) - the image passed the smoke test and was NOT pushed." echo "Re-run with push=true to publish it."