Runners

Runners are the machines that run the jobs of your pipelines. On this platform they are exclusively yours, not a pool of runners shared with other customers.

  • They run in a network dedicated to your organization and are registered to your top-level group.
  • They have their own storage, which only they can reach.
  • They cannot reach another customer's runners, and no other customer's runners can reach yours.

All runners are dynamic: a runner is created for each job and deleted afterwards. Every job starts from a clean state and idle capacity costs nothing. The trade-off is a short delay before a job begins.

When a job ends, its runner and the runner's disk are deleted. Files that you want to keep after the job, such as build output or test reports, must be saved as artifacts, in the cache, or in a registry.

Which runners you have

Runners are provisioned per customer, so what your group has depends on what was set up for you.

Runner Tags Best for
Linux linux The default choice for most jobs
Linux, with license access linux, license Linux runner with Vector license server access
Windows, without a container windows, shell Windows tooling that runs directly on the runner
Windows, in a container windows, docker Jobs inside a Windows container image
Windows, building images windows, dind Building Windows container images

Linux jobs need only the linux tag. Building container images on Linux does not need a different runner. Declare docker:dind as a service in the job, as in the example below.

Targeting a runner

Jobs are matched to runners by tag:

stages: [build, test, package]

build_job:
  stage: build
  tags: [windows, shell]
  script:
    - make build

test_job:
  stage: test
  tags: [linux]
  image: python:3.12
  script:
    - make test

# Building a container image needs a Docker daemon, declared as a service
package_job:
  stage: package
  tags: [linux]
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA" .

A few rules that save time:

  • Only runners with license access can run Vector tools. On Linux, check that your job runs on a runner with the license tag.
  • Windows jobs name the executor as well: windows plus shell, docker or dind.
  • Never mix windows and linux in one job. No runner carries both, so it will never start.
  • On Windows, docker and dind are different runners. A docker runner runs your job in a container but gives it no Docker daemon of its own.
  • Do not over-specify. Every extra tag narrows the set of runners that can pick the job up.

A pending job is nearly always a tag mismatch

If a job stays in pending, check that a runner in your group carries every tag the job asks for.

Job images

Your jobs run in container (OCI) images. linux runners can pull images from public registries. Otherwise, you can build them in your group with the DinD runners or on your computer and publish them to your Vector Collaboration Platform registries.

Registries

Build caches

Three caching features can be enabled for your group. Each is separate:

Feature What it does
Runner cache A shared cache between your runners behind GitLab's standard cache: keyword
sccache A compiler cache for C, C++ and Rust, reused across jobs and branches
Bazel remote cache A bazel-remote server for Bazel build and test outputs

All three work in pipelines only. Your runners can reach them; your computer cannot.

sccache

Your runners are given the two variables VECTOR_SCCACHE_BUCKET and VECTOR_SCCACHE_REGION. Map them to SCCACHE_BUCKET and SCCACHE_REGION so that sccache can read them.

build:
  tags: [linux]
  variables:
    SCCACHE_BUCKET: "$VECTOR_SCCACHE_BUCKET"
    SCCACHE_REGION: "$VECTOR_SCCACHE_REGION"
    RUSTC_WRAPPER: "sccache"   # Rust. For CMake use CMAKE_C[XX]_COMPILER_LAUNCHER=sccache,
                               # for plain make CC="sccache gcc" and CXX="sccache g++"
  script:
    - cargo build --release
    - sccache --show-stats

You need no credentials; the runner's own identity grants it access. sccache --show-stats at the end of a job is the quickest way to see whether the cache is being hit; a second run on the same commit that is still all misses usually means the compiler flags or the image changed. sccache must be present in your job image.

Bazel remote cache

Your runners are given the cache endpoint as VECTOR_BAZEL_CACHE_URL:

build:
  tags: [linux]
  script:
    - bazel build --remote_cache="$VECTOR_BAZEL_CACHE_URL" //...

Prefer the variable over a hostname written into a committed .bazelrc: the host differs per customer and per environment. If you do use .bazelrc, generate the line in before_script:

before_script:
  - echo "build --remote_cache=$VECTOR_BAZEL_CACHE_URL" >> .bazelrc

Cost limit

Runners are created on demand, so your organization sets a monthly budget for running its pipelines.

The limit is enforced, not just monitored

When your organization reaches the limit, active runners are shut down and their jobs fail. No new jobs start until the next month begins or the limit is raised.

Your repositories, registries and job artifacts are stored in GitLab itself and stay available.

For more information, ask your Vector contact or write to support@vector.com.

The budget is agreed when your organization is set up (see Onboarding your organization) and changed later through your Vector contact.

Licenses and the outside world

Use a runner with the license tag to run licensed Vector tools. These runners can get the license from a license server within the runner network. You are only allowed to use the licenses you own. Vector may restrict the number of these runners according to the number of licenses you own.

As of now, all windows runners have license access. Licensing

Your runners can connect only to hosts that have been approved for them (an allow list). If a job needs to reach any other host, such as your own artifact server or a vendor package index, the firewall must be changed first. Request this change through your Vector contact, and plan for it to take several days. Network access