Deploying GitLab Service on GKE

Q: Deploy the gitlab-service helm chart on Google Kubernetes Engine (GKE)

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

To deploy the GitLab service Helm chart on Google Kubernetes Engine (GKE) using Pulumi and TypeScript, we need to go through a few steps:

Set up a GKE cluster: We first need to declare a GKE cluster resource. This is where the GitLab service will run.
Install the GitLab Helm Chart: Once we have the GKE cluster set up, we then deploy the GitLab Helm chart onto the cluster.

Prerequisites

Before running the Pulumi program, ensure the following:

You have already set up the Pulumi CLI and authenticated with GCP.
You have kubectl installed and configured to interact with your Kubernetes clusters.
You have Helm CLI installed, as some commands might be required to fetch Helm chart values.

Pulumi Program (GKE Cluster and GitLab Helm Deployment)

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster('gitlab-gke-cluster', {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: 'n1-standard-1',
        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
export const clusterName = cluster.name;

// Export the Kubeconfig to access the GKE cluster
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
`;
    });

// Step 2: Deploy GitLab service Helm chart
const gitlabChart = new k8s.helm.v3.Chart('gitlab-chart', {
    chart: 'gitlab',
    fetchOpts:{
        repo: 'https://charts.gitlab.io/',
    },
    version: '4.0.0', // Replace with the version of GitLab Helm chart you want to deploy
    namespace: 'gitlab',
    values: {
        // Your custom GitLab Helm chart values here
    },
}, { provider: new k8s.Provider('gke-k8s', { kubeconfig: kubeConfig }) });

How the Program Works

We initialize a new GKE cluster using the gcp.container.Cluster class from the Pulumi GCP package. We configure the initial node count and machine type of the cluster's nodes along with the necessary OAuth scopes.
We then export the name of the cluster and the kubeconfig, which is required to interact with the cluster using kubectl.
In the second step, we create an instance of k8s.helm.v3.Chart which represents a Helm chart for GitLab. We provide it the name of the chart, the repository URL, and any custom values we wish to override in the GitLab chart. It's important to specify the correct chart version that matches the GitLab version you want to deploy.
The Helm chart is associated with the GKE cluster through a Kubernetes provider that is instantiated with the exported kubeconfig.

After crafting this program, you can deploy these resources using the Pulumi CLI by running pulumi up. This command will show you a preview of the resources that will be created and, upon confirmation, will provision them in your GCP account. After deployment, your GitLab service will be running on GKE, and you can manage it using kubectl and the Helm CLI.