Deploy the wekan-old helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `wekan-old` Helm chart on Google Kubernetes Engine (GKE), you will need to perform the following steps:

1. Set up a GKE cluster.
2. Configure the Kubernetes provider to interact with the GKE cluster.
3. Deploy the Helm chart to the cluster using Pulumi's `helm.v3.Chart` resource.

Here is a detailed overview of the process and the Pulumi program in TypeScript to accomplish it:

### Set up a GKE cluster

First, you have to declare a GKE cluster resource. We will use Pulumi's `gcp.container.Cluster` class from the `@pulumi/gcp` package to create a new cluster. The cluster will be the environment where your Helm chart will be deployed.

### Configure the Kubernetes provider

Once you've created your GKE cluster, you need to configure Pulumi to use the correct Kubernetes context. This is done by creating a Kubernetes provider instance with the kubeconfig obtained from the newly created GKE cluster.

### Deploy the Helm chart

After setting up the required infrastructure and configuring the providers, you can deploy the Helm chart. The `helm.v3.Chart` class from the `@pulumi/kubernetes` package is used to deploy the `wekan-old` chart. You'll need to specify the chart name, version (if you need a specific one), and introduce any required values or configuration overrides.

Below is a Pulumi program in TypeScript that shows how to perform these steps:

```typescript
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("my-gke-cluster", {
    initialNodeCount: 3,
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

// Step 2: Configure the Kubernetes provider
const k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: cluster.endpoint.apply(endpoint => `apiVersion: v1
clusters:
- cluster:
   certificate-authority-data: ${cluster.masterAuth.clusterCaCertificate}
   server: https://${endpoint}
 name: gke-cluster
contexts:
- context:
   cluster: gke-cluster
   user: gke-cluster-user
 name: gke-context
current-context: gke-context
kind: Config
preferences: {}
users:
- name: gke-cluster-user
  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
`),
    context: "gke-context",
});

// Step 3: Deploy the Helm chart to the GKE cluster
const wekanChart = new k8s.helm.v3.Chart("wekan-old", {
    chart: "wekan",
    version: "old",  // specify the version you want to deploy
    fetchOpts: {
        repo: "http://wekan.github.io/charts", // specify the Helm chart repository
    },
    values: {
        // Put your required chart values here, example:
        mongodb: {
            persistence:{
                enabled: true,
                size: "8Gi",
            },
        },
    },
}, { provider: k8sProvider });

// Export the Kubeconfig to access the cluster
export const kubeconfig = k8sProvider.kubeconfig;
```

Ensure that you have the correct Helm chart repository URL for `wekan-old`. If there is a specific chart version tagged as `old`, replace `version: "old"` with the correct version string.

Remember that the `values` object in the `helm.v3.Chart` resource must be customized to the configuration parameters that `wekan-old` requires. Check the chart's documentation or `values.yaml` to know what values you can configure.

Once you deploy this Pulumi program using `pulumi up`, the specified Helm chart will be installed on your GKE cluster. You can then manage the Helm release and its resources with Pulumi.