Tutorial: Configure GitLab Runner to use the Google Kubernetes Engine

This tutorial describes how to configure GitLab Runner to use the Google Kubernetes Engine (GKE) to run jobs.

In this tutorial, you configure GitLab Runner to run jobs in the following GKE cluster modes:

  • Autopilot
  • Standard

To configure GitLab Runner to use the GKE:

  1. Set up your environment.
  2. Create and connect to a cluster.
  3. Install and configure the Kubernetes Operator.
  4. Optional. Verify that the configuration was successful.


Before you can configure GitLab Runner to use the GKE you must:

Set up your environment

Install the tools to configure and use GitLab Runner in the GKE.

  1. Install and configure Google Cloud CLI. You use Google Cloud CLI to connect to the cluster.
  2. Install and configure kubectl. You use kubectl to communicate with the remote cluster from your local environment.

Create and connect to a cluster

This step describes how to create a cluster and connect to it. After you connect to the cluster, you use kubectl to interact with it and, for autopilot clusters, to add configurations that specify which jobs to run.

  1. In the Google Cloud Platform, create an autopilot or standard cluster.

  2. Install the kubectl authentication plugin:

    gcloud components install gke-gcloud-auth-plugin
  3. Connect to the cluster:

    gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_LOCATION
  4. View the cluster configuration:

    kubectl config view
  5. Verify that you are connected to the cluster:

    kubectl config current-context

Install and configure the Kubernetes Operator

Now that you have a cluster, you’re ready to install and configure the Kubernetes Operator.

  1. Install the prerequisites:

    kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.7.1/cert-manager.yaml
  2. Install the Operator Lifecycle Manager (OLM), a tool that manages the Kubernetes Operators that run on the cluster:

    curl --silent --location "https://github.com/operator-framework/operator-lifecycle-manager/releases/download/v0.24.0/install.sh" \
     | bash -s v0.24.0
  3. Install the Kubernetes Operator Catalog:

    kubectl create -f https://raw.githubusercontent.com/operator-framework/operator-lifecycle-manager/master/deploy/upstream/quickstart/crds.yaml
    kubectl create -f https://raw.githubusercontent.com/operator-framework/operator-lifecycle-manager/master/deploy/upstream/quickstart/olm.yaml
  4. Install the Kubernetes Operator:

    kubectl create -f https://operatorhub.io/install/gitlab-runner-operator.yaml
  5. Create a secret that contains the runner-registration-token from your GitLab project:

     cat > gitlab-runner-secret.yml << EOF
     apiVersion: v1
     kind: Secret
       name: gitlab-runner-secret
     type: Opaque
    runner-registration-token: YOUR_RUNNER_REGISTRATION_TOKEN
  6. Apply the secret:

    kubectl apply -f gitlab-runner-secret.yml
  7. For autopilot clusters, you must create a YAML file with additional configuration details. Autopilot clusters use this file to instruct the GKE about what resources the Pod needs so it can run the jobs. You don’t need to create this file for standard clusters. Here is an example configuration:

    cat > config.yml << EOF
    apiVersion: v1
    kind: configMaps
      name: config.toml
    config: |
        image = "alpine"
        cpu_limit = "1"
        memory_limit = "128Mi"
        service_cpu_limit = "1"
        service_memory_limit = "128Mi"
        helper_cpu_limit = "500m"
        helper_memory_limit = "100Mi"
  8. Apply the config.yml:

    kubectl apply -f config.yml
  9. Create the custom resource definition file and include the following information:

    cat > gitlab-runner.yml << EOF
       apiVersion: apps.gitlab.com/v1beta2
          kind: Runner
          name: gitlab-runner
          gitlabUrl: https://gitlab.example.com
          buildImage: alpine
          config: "config.toml"  # <---- Reference to the config.toml configMap
          token: gitlab-runner-secret
  10. Apply the custom resource definition file:

    kubectl apply -f gitlab-runner.yml

That’s it! You’ve configured GitLab Runner to use the GKE. In the next step, you can check if your configuration is working.

Verify your configuration

To check if runners are running in the GKE cluster, you can either:

  • Use the following command:

    kubectl get pods

    You should see the following output. This shows that your runners are running in the GKE cluster:

    NAME                             READY   STATUS    RESTARTS   AGE
    gitlab-runner-hash-short_hash    1/1     Running   0          5m
  • Check the job log in GitLab:

    1. On the left sidebar, select Search or go to and find your project.
    2. Select Build > Jobs and find the job.
    3. To view the job log, select the job status.