ci: publish aligned Docker images

Anbeeld · Anbeeld · commit 4b1a944de9b1 · 2026-06-01T11:07:07.000+02:00
diff --git a/.devops/cuda.Dockerfile b/.devops/cuda.Dockerfile
@@ -1,6 +1,8 @@
-ARG UBUNTU_VERSION=24.04
+# syntax=docker/dockerfile:1.7
+
+ARG UBUNTU_VERSION=22.04
 # This needs to generally match the container host's environment.
-ARG CUDA_VERSION=12.8.1
+ARG CUDA_VERSION=12.4.1
 # Target the CUDA build image
 ARG BASE_CUDA_DEV_CONTAINER=nvidia/cuda:${CUDA_VERSION}-devel-ubuntu${UBUNTU_VERSION}
 
@@ -14,21 +16,44 @@ FROM ${BASE_CUDA_DEV_CONTAINER} AS build
 
 # CUDA architecture to build for (defaults to all supported archs)
 ARG CUDA_DOCKER_ARCH=default
+# CMake target to build. Keep "all" for full/local images; CI server images set this to llama-server.
+ARG CUDA_BUILD_TARGET=all
 
-RUN apt-get update && \
-    apt-get install -y gcc-14 g++-14 build-essential cmake python3 python3-pip git libssl-dev libgomp1
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
+    apt-get update && \
+    apt-get install -y --no-install-recommends build-essential cmake ninja-build ccache python3 python3-pip git libssl-dev libgomp1 && \
+    rm -rf /var/lib/apt/lists/*
 
-ENV CC=gcc-14 CXX=g++-14 CUDAHOSTCXX=g++-14
+ENV CC=gcc CXX=g++ CUDAHOSTCXX=g++ CCACHE_SLOPPINESS=time_macros CCACHE_MAXSIZE=2G
 
 WORKDIR /app
 
 COPY . .
 
-RUN if [ "${CUDA_DOCKER_ARCH}" != "default" ]; then \
+RUN --mount=type=cache,target=/root/.ccache \
+    if [ "${CUDA_DOCKER_ARCH}" != "default" ]; then \
     export CMAKE_ARGS="-DCMAKE_CUDA_ARCHITECTURES=${CUDA_DOCKER_ARCH}"; \
     fi && \
-    cmake -B build -DGGML_NATIVE=OFF -DGGML_CUDA=ON -DGGML_BACKEND_DL=ON -DGGML_CPU_ALL_VARIANTS=ON -DLLAMA_BUILD_TESTS=OFF ${CMAKE_ARGS} -DCMAKE_EXE_LINKER_FLAGS=-Wl,--allow-shlib-undefined . && \
-    cmake --build build --config Release -j$(nproc)
+    cmake -S . -B build -G Ninja \
+      -DGGML_NATIVE=OFF \
+      -DGGML_CUDA=ON \
+      -DGGML_CUDA_FA=ON \
+      -DGGML_CUDA_FA_ALL_QUANTS=ON \
+      -DGGML_BACKEND_DL=ON \
+      -DGGML_CPU_ALL_VARIANTS=ON \
+      -DLLAMA_BUILD_TESTS=OFF \
+      -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+      -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+      -DCMAKE_CUDA_COMPILER_LAUNCHER=ccache \
+      ${CMAKE_ARGS} \
+      -DCMAKE_EXE_LINKER_FLAGS=-Wl,--allow-shlib-undefined && \
+    if [ "${CUDA_BUILD_TARGET}" = "all" ]; then \
+      cmake --build build --config Release -j"$(nproc)"; \
+    else \
+      cmake --build build --config Release -j"$(nproc)" --target "${CUDA_BUILD_TARGET}"; \
+    fi && \
+    ccache --show-stats
 
 RUN mkdir -p /app/lib && \
     find build -name "*.so*" -exec cp -P {} /app/lib \;
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
@@ -4,12 +4,14 @@ on:
   push:
     branches:
       - main
+      - "v*"
     tags:
       - "v*"
+  workflow_dispatch:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: false
+  cancel-in-progress: ${{ github.ref_type == 'branch' }}
 
 permissions:
   contents: read
@@ -22,7 +24,10 @@ jobs:
     outputs:
       image_repo: ${{ steps.meta.outputs.image_repo }}
       version: ${{ steps.meta.outputs.version }}
+      ref_name_safe: ${{ steps.meta.outputs.ref_name_safe }}
+      short_sha: ${{ steps.meta.outputs.short_sha }}
       publish: ${{ steps.meta.outputs.publish }}
+      release: ${{ steps.meta.outputs.release }}
     steps:
       - name: Check out the repo
         uses: actions/checkout@v6
@@ -36,34 +41,51 @@ jobs:
           set -euo pipefail
 
           publish="false"
+          release="false"
           short_sha="${GITHUB_SHA::12}"
           exact_tag="$(git tag --points-at "${GITHUB_SHA}" --list 'v*' | sort -V | tail -n 1 || true)"
+          ref_name_safe="$(printf '%s' "${GITHUB_REF_NAME}" | tr '[:upper:]' '[:lower:]' | sed -E 's#[^a-z0-9_.-]+#-#g; s#^[.-]+##; s#[.-]+$##')"
+          if [[ -z "${ref_name_safe}" ]]; then
+            ref_name_safe="${short_sha}"
+          fi
 
-          if [[ "${GITHUB_EVENT_NAME}" == "push" && "${GITHUB_REF}" == refs/tags/v* ]]; then
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
             version="${GITHUB_REF_NAME}"
             git fetch origin +refs/heads/main:refs/remotes/origin/main --no-tags
             if git merge-base --is-ancestor "${GITHUB_SHA}" refs/remotes/origin/main; then
               publish="true"
+              release="true"
             else
               echo "Tag ${GITHUB_REF_NAME} is not on origin/main; skipping Docker publish."
             fi
-          elif [[ "${GITHUB_EVENT_NAME}" == "push" && "${GITHUB_REF}" == "refs/heads/main" && -n "${exact_tag}" ]]; then
+          elif [[ "${GITHUB_REF}" == "refs/heads/main" && -n "${exact_tag}" ]]; then
             version="${exact_tag}"
             publish="true"
+            release="true"
+          elif [[ "${GITHUB_REF}" == "refs/heads/main" || "${GITHUB_REF}" == refs/heads/v* ]]; then
+            version="${ref_name_safe}-${short_sha}"
+            publish="true"
+          elif [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]; then
+            version="${ref_name_safe}-${short_sha}"
+            publish="true"
           else
-            version="${GITHUB_REF_NAME//\//-}-${short_sha}"
+            version="${ref_name_safe}-${short_sha}"
           fi
 
           owner="$(echo "${GITHUB_REPOSITORY_OWNER}" | tr '[:upper:]' '[:lower:]')"
           repo="$(echo "${GITHUB_REPOSITORY#*/}" | tr '[:upper:]' '[:lower:]')"
           image_repo="ghcr.io/${owner}/${repo}"
 
-          echo "version=${version}" >> "${GITHUB_OUTPUT}"
           echo "image_repo=${image_repo}" >> "${GITHUB_OUTPUT}"
+          echo "version=${version}" >> "${GITHUB_OUTPUT}"
+          echo "ref_name_safe=${ref_name_safe}" >> "${GITHUB_OUTPUT}"
+          echo "short_sha=${short_sha}" >> "${GITHUB_OUTPUT}"
           echo "publish=${publish}" >> "${GITHUB_OUTPUT}"
+          echo "release=${release}" >> "${GITHUB_OUTPUT}"
           echo "Using image repository: ${image_repo}"
           echo "Using version: ${version}"
           echo "Publish Docker images: ${publish}"
+          echo "Release Docker tags: ${release}"
 
   build:
     name: Build server${{ matrix.config.display_suffix }}
@@ -82,17 +104,23 @@ jobs:
             platforms: linux/amd64,linux/arm64
             free_disk_space: false
           - name: cuda12
-            display_suffix: " CUDA 12"
+            display_suffix: " CUDA 12.4"
             dockerfile: .devops/cuda.Dockerfile
-            cuda_version: "12.8.1"
+            cuda_version: "12.4.1"
+            ubuntu_version: "22.04"
+            cuda_arch: "default"
+            cuda_build_target: "llama-server"
             tag_suffixes: "-cuda -cuda12"
             cache_name: cuda12
             platforms: linux/amd64
             free_disk_space: true
           - name: cuda13
-            display_suffix: " CUDA 13"
+            display_suffix: " CUDA 13.1"
             dockerfile: .devops/cuda.Dockerfile
             cuda_version: "13.1.1"
+            ubuntu_version: "24.04"
+            cuda_arch: "default"
+            cuda_build_target: "llama-server"
             tag_suffixes: "-cuda13"
             cache_name: cuda13
             platforms: linux/amd64
@@ -153,6 +181,9 @@ jobs:
         env:
           IMAGE_REPO: ${{ needs.docker-meta.outputs.image_repo }}
           VERSION: ${{ needs.docker-meta.outputs.version }}
+          REF_NAME_SAFE: ${{ needs.docker-meta.outputs.ref_name_safe }}
+          SHORT_SHA: ${{ needs.docker-meta.outputs.short_sha }}
+          RELEASE_TAGS: ${{ needs.docker-meta.outputs.release }}
           TAG_SUFFIXES: ${{ matrix.config.tag_suffixes }}
           CACHE_NAME: ${{ matrix.config.cache_name }}
         run: |
@@ -163,8 +194,14 @@ jobs:
             if [[ "${suffix}" == "none" ]]; then
               suffix=""
             fi
-            tags+=("${IMAGE_REPO}:server${suffix}")
-            tags+=("${IMAGE_REPO}:server${suffix}-${VERSION}")
+
+            if [[ "${RELEASE_TAGS}" == "true" ]]; then
+              tags+=("${IMAGE_REPO}:server${suffix}")
+              tags+=("${IMAGE_REPO}:server${suffix}-${VERSION}")
+            else
+              tags+=("${IMAGE_REPO}:server${suffix}-${REF_NAME_SAFE}-dev")
+              tags+=("${IMAGE_REPO}:server${suffix}-${REF_NAME_SAFE}-${SHORT_SHA}")
+            fi
           done
 
           {
@@ -193,7 +230,10 @@ jobs:
             APP_REVISION=${{ github.sha }}
             IMAGE_URL=${{ github.server_url }}/${{ github.repository }}
             IMAGE_SOURCE=${{ github.server_url }}/${{ github.repository }}
+            ${{ matrix.config.ubuntu_version && format('UBUNTU_VERSION={0}', matrix.config.ubuntu_version) || '' }}
             ${{ matrix.config.cuda_version && format('CUDA_VERSION={0}', matrix.config.cuda_version) || '' }}
+            ${{ matrix.config.cuda_arch && format('CUDA_DOCKER_ARCH={0}', matrix.config.cuda_arch) || '' }}
+            ${{ matrix.config.cuda_build_target && format('CUDA_BUILD_TARGET={0}', matrix.config.cuda_build_target) || '' }}
           annotations: |
             manifest:org.opencontainers.image.created=${{ steps.build_date.outputs.date }}
             manifest:org.opencontainers.image.version=${{ needs.docker-meta.outputs.version }}
diff --git a/docs/docker.md b/docs/docker.md
@@ -1,6 +1,6 @@
 # Docker
 
-BeeLlama Docker images are published by the daily/manual Docker workflow to
+BeeLlama Docker images are published by the push/manual Docker workflow to
 `ghcr.io/anbeeld/beellama.cpp`. CUDA images are built from the stock
 `.devops/cuda.Dockerfile`; pass `CUDA_DOCKER_ARCH` when building locally for a
 specific GPU generation, for example `120` for Blackwell or `86` for RTX 3090.
@@ -22,8 +22,8 @@ Additionally, there the following images, similar to the above:
 - `ghcr.io/anbeeld/beellama.cpp:full-cuda13`: Same as `full` but compiled with CUDA 13 support. (platforms: `linux/amd64`, `linux/arm64`)
 - `ghcr.io/anbeeld/beellama.cpp:light-cuda`: Same as `light` but compiled with CUDA 12 support. (platforms: `linux/amd64`, `linux/arm64`)
 - `ghcr.io/anbeeld/beellama.cpp:light-cuda13`: Same as `light` but compiled with CUDA 13 support. (platforms: `linux/amd64`, `linux/arm64`)
-- `ghcr.io/anbeeld/beellama.cpp:server-cuda`: Same as `server` but compiled with CUDA 12 support. (platforms: `linux/amd64`, `linux/arm64`)
-- `ghcr.io/anbeeld/beellama.cpp:server-cuda13`: Same as `server` but compiled with CUDA 13 support. (platforms: `linux/amd64`, `linux/arm64`)
+- `ghcr.io/anbeeld/beellama.cpp:server-cuda`: Same as `server` but compiled with CUDA 12.4 support. (platforms: `linux/amd64`)
+- `ghcr.io/anbeeld/beellama.cpp:server-cuda13`: Same as `server` but compiled with CUDA 13.1 support. (platforms: `linux/amd64`)
 - `ghcr.io/anbeeld/beellama.cpp:full-rocm`: Same as `full` but compiled with ROCm support. (platforms: `linux/amd64`)
 - `ghcr.io/anbeeld/beellama.cpp:light-rocm`: Same as `light` but compiled with ROCm support. (platforms: `linux/amd64`)
 - `ghcr.io/anbeeld/beellama.cpp:server-rocm`: Same as `server` but compiled with ROCm support. (platforms: `linux/amd64`)
@@ -93,7 +93,8 @@ You may want to pass in some different `ARGS`, depending on the CUDA environment
 
 The defaults are:
 
-- `CUDA_VERSION` set to `12.8.1`
+- `CUDA_VERSION` set to `12.4.1`
+- `UBUNTU_VERSION` set to `22.04`
 - `CUDA_DOCKER_ARCH` set to the cmake build default, which includes all the supported architectures
 
 The resulting images, are essentially the same as the non-CUDA images:
