Deploy the kamaji helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Kamaji Helm chart on Google Kubernetes Engine (GKE), you'll need to complete the following steps:

1. Create a GKE cluster.
2. Set up a Kubeconfig file to interact with your cluster using `kubectl`, Pulumi's Kubernetes provider will leverage this.
3. Install the Helm chart into the cluster.

For this, you will use Pulumi's Google Cloud (GCP) provider to provision the GKE cluster and the Kubernetes provider to deploy the Kamaji Helm chart. The `harness.platform.KubernetesConnector` and `harness.service.Helm` resources found in the Pulumi Registry Results are actually from the Harness provider and are not directly relevant to deploying a Helm chart on GKE with Pulumi.

Here is a complete Pulumi program in TypeScript that accomplishes these steps:

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

const name = "kamaji-cluster";
const project = process.env["PROJECT_ID"]; // Ensure your Google Cloud project ID is in the environment variable

// Step 1. Create a GKE cluster
const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 1,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Or any other preferred 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
export const clusterName = cluster.name;

// Obtain the Kubeconfig for the created cluster.
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${project}_${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 3. Deploy Kamaji Helm chart into the cluster
const kamajiChart = new k8s.helm.v3.Chart("kamaji-helm-chart", {
    chart: "kamaji",
    version: "0.1.0", // Replace with the correct chart version
    fetchOpts: {
        repo: "http://kamaji-charts.storage.googleapis.com", // Replace with the correct repository URL if different
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeconfig }) });

// Export the Helm chart resources
export const helmChartResources = kamajiChart.resources;
```

### Explanation

1. The `gcp.container.Cluster` resource is used to create a GKE cluster. It's defined with a set of basic configurations such as node count and machine type. You can adjust these parameters to fit your specific needs.

2. After creating the cluster, we generate a Kubeconfig file using Pulumi's `pulumi.all().apply` method. This allows us to interpolate the necessary values (such as the cluster endpoint and master authentication credentials) dynamically.

3. Finally, the `k8s.helm.v3.Chart` resource is instantiated to deploy the Kamaji Helm chart to the cluster. We pass the previously obtained Kubeconfig to a `k8s.Provider`, which is used for authentication.

### Before Running the Program

- Make sure you have Pulumi CLI and `gcloud` CLI installed.
- Ensure that you're authenticated with the Google Cloud (`gcloud auth login`) and have set the correct project (`gcloud config set project YOUR_PROJECT_ID`).
- Install the required NPM packages by running `npm install @pulumi/gcp @pulumi/kubernetes @pulumi/pulumi`.

Place the code above in an `index.ts` file, then run `pulumi up` to preview and deploy the resources. This will provision a GKE cluster and deploy the Kamaji Helm chart to it.

Remember to replace `"http://kamaji-charts.storage.googleapis.com"` and `version: "0.1.0"` with the actual Helm repository URL and chart version, respectively, if they are different.