Deploy the cluster-gitlab-runner helm chart on Linode Kubernetes Engine

Deploying GitLab Runner on Linode Kubernetes

Deploying a Helm chart on a Kubernetes cluster provisioned with Pulumi involves several steps. Firstly, we need to provision a Linode Kubernetes Engine (LKE) cluster. After the cluster is up and running, we then deploy the Helm chart to this cluster.

Here's an overview of the steps we'll take in the Pulumi program:

Provision the Linode Kubernetes Engine Cluster: This will involve creating a new Kubernetes cluster in Linode using the linode.LkeCluster resource from the @pulumi/linode package.
Configure Kubernetes Provider: Once the LKE cluster is up, we'll set up the Kubernetes provider to point to the newly created cluster. This involves fetching the kubeconfig for the LKE cluster and using it to configure the Kubernetes provider.
Deploy the GitLab Runner Helm Chart: With the Kubernetes provider configured, we'll use the kubernetes.helm.v3.Chart resource from the @pulumi/kubernetes package to deploy the cluster-gitlab-runner Helm chart.

Here is the program written in TypeScript:

import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Provision the Linode Kubernetes Engine Cluster
const cluster = new linode.LkeCluster("lke-cluster", {
    // Specify the Kubernetes version, region, and node types
    k8sVersion: "1.21",
    region: "us-central",
    pools: [{
        count: 2, // number of nodes
        type: "g6-standard-2", // node instance size
    }],
});

// Step 2: Configure Kubernetes Provider
// Fetch the kubeconfig from the LKE cluster
const kubeconfig = pulumi.all([cluster.id, cluster.kubeconfig]).apply(([_, kubeconfig]) => {
    return kubeconfig.rawConfig;
});

// Create a Kubernetes provider instance using the fetched kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the GitLab Runner Helm Chart
const gitlabRunnerChart = new k8s.helm.v3.Chart("gitlab-runner-chart", {
    // Specify the chart details and repository
    chart: "gitlab-runner",
    version: "0.29.0", // use the version that matches your needs
    fetchOpts: {
        repo: "https://charts.gitlab.io/",
    },
    // Provide any custom values to the Helm chart
    values: {
        // ... add your configuration (if any)
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and endpoint
export const kubeconfigOutput = kubeconfig;
export const clusterEndpoint = cluster.endpoint;

Explanation:

The linode.LkeCluster resource is used to create a new Kubernetes cluster in Linode's cloud environment. You need to specify the version of Kubernetes, the region where the cluster will be provisioned, and details about the node pools, such as the number of nodes and their types.
The kubeconfig is obtained from the LKE cluster, which allows us to interact with the cluster using the Kubernetes API.
We create a new instance of k8s.Provider that will use the kubeconfig from the LKE cluster. This tells Pulumi how to communicate with our Kubernetes cluster.
The k8s.helm.v3.Chart resource is then used to deploy the gitlab-runner Helm chart to the Linode Kubernetes cluster. You can specify the version of the chart and any additional configuration needed for the GitLab Runner.
We export the cluster's kubeconfig and API endpoint as stack outputs, so you can easily access them once the program has finished running.

Please ensure you have the Pulumi CLI installed and configured with your Linode API Token. You also need to have Node.js and npm installed to run the TypeScript program. Save this in a .ts file and deploy it using pulumi up. The CLI will guide you through the process.