Deploy the cluster-gitlab-runner helm chart on Google Kubernetes Engine (GKE)

Deploying GitLab Runner Using Helm on GKE

To fulfill the task of deploying a Helm chart on Google Kubernetes Engine (GKE), you need to follow these steps:

Create a GKE cluster where the Helm chart will be deployed.
Install and configure Helm, which is a package manager for Kubernetes, to manage deployments within the cluster.
Deploy the cluster-gitlab-runner Helm chart to the GKE cluster.

In order to accomplish this with Pulumi, we'll write a TypeScript program that does the following:

Uses the @pulumi/gcp package to create a GKE cluster.
Leverages the @pulumi/kubernetes package to set up Helm and deploy the GitLab Runner Helm chart.

Firstly, you need to have Pulumi installed and set up with access to a Google Cloud Platform (GCP) account. This involves configuring credentials for Pulumi to interact with your GCP account and potentially setting some default configuration values, like your GCP project ID.

Now we can move on to writing our Pulumi program.

import * as pulumi from '@pulumi/pulumi';
import * as gcp from '@pulumi/gcp';
import * as k8s from '@pulumi/kubernetes';

// Create a GKE cluster
const cluster = new gcp.container.Cluster('gitlab-runner-cluster', {
    initialNodeCount: 1,
    minMasterVersion: 'latest', // Use the latest GKE Master version
    nodeVersion: 'latest', // Use the latest GKE Node version
    nodeConfig: {
        machineType: 'n1-standard-1', // Choose an adequate machine type
        oauthScopes: [
            'https://www.googleapis.com/auth/compute',
            'https://www.googleapis.com/auth/devstorage.read_only',
            'https://www.googleapis.com/auth/logging.write',
            'https://www.googleapis.com/auth/monitoring',
        ],
    },
});

// Export the Cluster name and kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = pulumi.
    all([ cluster.name, cluster.endpoint, cluster.masterAuth ]).
    apply(([ name, endpoint, masterAuth ]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

// Create a k8s provider using the kubeconfig from the created cluster
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeconfig,
});

// Deploy the cluster-gitlab-runner Helm Chart
const gitlabRunner = new k8s.helm.v3.Chart('gitlab-runner', {
    chart: 'cluster-gitlab-runner',
    version: '0.3.0', // Specify chart version
    fetchOpts:{
        repo: 'https://charts.gitlab.io/',
    },
}, { provider: k8sProvider });

// Export GitLab Runner Helm release status
export const gitlabRunnerStatus = gitlabRunner.status;

Explanation

In this program:

We are using the @pulumi/gcp package to create a new GKE cluster named gitlab-runner-cluster.
The kubeconfig is generated using the cluster details, which allows us to interact with the cluster using kubectl.
We defined a Pulumi Kubernetes provider, k8sProvider, that uses the kubeconfig. This is necessary to communicate with the GKE cluster through Pulumi.
We then declared the Helm chart for cluster-gitlab-runner using Pulumi's Helm support in the @pulumi/kubernetes package, specifying the version and the repository where the chart is located.
Finally, we exported the cluster name and the status of the Helm deployment.

Make sure to replace version: '0.3.0' with the actual version of the cluster-gitlab-runner Helm chart you wish to deploy.

When you run pulumi up with this program, Pulumi will provision the required resources in the correct order. Firstly, it will create a GKE cluster, then it will deploy the cluster-gitlab-runner Helm chart into the cluster using Helm.

Keep in mind that the actual deployment of the Helm chart may require more configuration steps, such as setting up GitLab Runner specific values like the GitLab URL, Runner registration tokens, and any custom configurations specific to your environment which can be supplied within the values field of the Chart resource.