Deploy the mattermost-instance helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to a Google Kubernetes Engine (GKE) cluster involves setting up the GKE cluster and then deploying the Helm chart to it using Pulumi. The steps will involve creating the necessary cloud resources with Pulumi, and using the `kubernetes.helm.sh/v3.Release` resource to deploy the Mattermost instance via Helm.

Below is a step-by-step guide and a Pulumi TypeScript program to achieve this:

### Step 1: Setup GKE Cluster
First, we will create a GKE cluster. A cluster consists of at least one cluster master machine and multiple worker machines called nodes. These control plane and node machines run the Kubernetes cluster orchestration system.

### Step 2: Configure Kubernetes Provider
Once the cluster is ready, we will configure Pulumi to use the newly created cluster as the Kubernetes provider which tells Pulumi where to deploy Kubernetes resources.

### Step 3: Deploy Helm Chart
Lastly, we will create a Helm Release using Pulumi's `kubernetes.helm.sh/v3.Release` resource which is responsible for deploying Helm charts. In this case, we will deploy the Mattermost Helm chart to our GKE cluster.

We will write the TypeScript program with explanatory comments:

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

// Set up GKE cluster configuration
const clusterConfig = {
    name: "mattermost-cluster",
    machineType: "n1-standard-1",
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest GKE version
};

// Create the GKE cluster
const cluster = new gcp.container.Cluster("mattermost-cluster", {
    initialNodeCount: clusterConfig.initialNodeCount,
    minMasterVersion: clusterConfig.minMasterVersion,
    nodeVersion: clusterConfig.minMasterVersion,
    name: clusterConfig.name,
    nodeConfig: {
        machineType: clusterConfig.machineType,
        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;

// Get the Kubeconfig of the created cluster
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
`;
    });

// Export the Kubeconfig
export const kubeConfig = kubeconfig;

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the Mattermost Helm chart
const mattermostChart = new k8s.helm.v3.Chart("mattermost-instance", {
    chart: "mattermost",
    version: "5.31.0", // Use the version of Mattermost that you wish to deploy
    fetchOpts:{repo: "https://helm.mattermost.com/"},
}, { provider: k8sProvider });

// Export the Mattermost instance endpoint
export const mattermostEndpoint = pulumi.interpolate `http://${cluster.endpoint}`;
```

### Explanation:
1. We import the `@pulumi/pulumi`, `@pulumi/gcp` and `@pulumi/kubernetes` libraries which provide us with the Pulumi primitives used to create and manage resources.
2. We define the configuration for our GKE cluster, including the machine type, initial node count, and GKE version.
3. We instantiate the GKE cluster using `gcp.container.Cluster` and provide it with our configuration.
4. Then we create a kubeconfig that can be used outside the program to interact with the Kubernetes cluster.
5. We set up a Pulumi Kubernetes Provider to interact with our newly created GKE cluster using the generated kubeconfig from step 4.
6. Finally, we deploy the Mattermost Helm chart using the `Chart` resource from `k8s.helm.v3`. We specify the chart name, version, and repository location.
7. We export the name of the GKE cluster, the kubeconfig, and the Mattermost service endpoint so that they can be accessed outside the program.

You can now apply the above program using Pulumi to deploy the Mattermost instance to your GKE cluster. Make sure you have the required GCP and Pulumi CLI set up and configured on your system where you intend to run this code. Once deployed, you will receive an endpoint URL that you can use to access Mattermost.