This Terraform modules creates a GitLab CI runner.

The runners created by the module use preemptible instances by default for running the builds using the docker+machine executor.

• Shared cache in GCS with life cycle management to clear objects after x days.
• Runner agents registered automatically.

The runner supports:

In this scenario the runner agent is running on a GCP Compute Instance and runners are created by docker machine using preemptible instances. Runners will scale automatically based on the configuration. The module creates a GCS cache by default, which is shared across runners (preemptible instances).

In this scenario not docker machine is used but docker to schedule the builds. Builds will run on the same compute instance as the agent.

See gke-runner

Both docker-machine runner and docker runners autoscale using GCP Custom metrics. The runner publishes running jobs metrics to stackdriver which is then used to scale up/down the number of active runners. var.runners_min_replicas and var.runners_max_replicas defined variables for the minimum and maximum number of runners respectively. It uses Google Managed Instance Group Autoscaler to scale when the average of running jobs exceeds var.runners_concurrent.

⚠️ With scaling up and down, runners can get terminated without waiting for clean up when GCP scales down. GCP shutdown scripts have a maximum of atmost 90 seconds, during which it's forcefully terminated. Hence, it might not wait for your jobs to finish during scale down. This can leave orphan docker-machine-created instances and failed jobs. Use this with caution. Advisably, if you need more than one runner, set var.runner_min_replicas = var.runners_max_replicas = number of runners you need.

The runner is registered on initial deployment. Each new runner registers itself with the same description and tag. To register the runner automatically set the variable gitlab_runner_registration_config["registration_token"]. This token value can be found in your GitLab project, group, or global settings. For a generic runner you can find the token in the admin section. By default the runner will be locked to the target project, not run untagged. Below is an example of the configuration map.

gitlab_runner_registration_config = {
  registration_token = "Required: <registration token>"
  tag_list           = "Optional: <your tags, comma separated>"
  description        = "Optional: <some description>"
  locked_to_project  = "optional: true"
  run_untagged       = "Optional: false"
  maximum_timeout    = "Optional: 3600"
  access_level       = "Optional: <not_protected OR ref_protected, ref_protected runner will only run on pipelines triggered on protected branches. Defaults to not_protected>"
}

By default the module creates a a cache for the runner in Google Cloud Storage. Old objects are automatically removed via a configurable life cycle policy on the bucket.

module "runner" {
  source  = "DeimosCloud/gitlab-ci-runner/google"

  network    = "default"
  subnetwork = "someNetwork"
  region     = "europe-west1"
  project    = local.project_id

  runners_name       = "docker-default"
  runners_gitlab_url = "https://gitlab.com"

  gitlab_runner_registration_config = {
    registration_token = "my-token"
    tag_list           = "docker"
  }

}

NOTE: If runners are set to use internal IPs, a Cloud NAT must be deployed for runners to be able to reach internet

Report issues/questions/feature requests on in the issues section.

Full contributing guidelines are covered here.

{
  "access_level": "not_protected",
  "description": "",
  "locked_to_project": "",
  "maximum_timeout": "",
  "registration_token": "",
  "run_untagged": "",
  "tag_list": ""
}

list(object({
    periods    = list(string)
    idle_count = number
    idle_time  = number
    timezone   = string
  }))

list(object({
    volume  = string
    options = string
  }))

[
  "0.0.0.0/0"
]

list(object({
    volume  = string
    options = string
  }))

No outputs.