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
licensetag. - Windows jobs name the executor as well:
windowsplusshell,dockerordind. - Never mix
windowsandlinuxin one job. No runner carries both, so it will never start. - On Windows,
dockeranddindare different runners. Adockerrunner 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.
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