Deploy the kanister-mongodb-replicaset helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Google Kubernetes Engine (GKE) cluster involves several steps. First, you need to create a GKE cluster, then you install the Helm CLI tool, and finally you use Helm to deploy the chart. I'll guide you through the process using Pulumi and TypeScript to codify these steps.

We will use the following Pulumi resources to accomplish this task:

1. `google-native.container/v1beta1.Cluster`: This resource will create a GKE cluster where our MongoDB ReplicaSet will be deployed.
2. `harness.platform.KubernetesConnector` and `harness.service.Helm`: These resources are used to manage and deploy Helm charts on Kubernetes through the Harness platform. For the purpose of simplicity and since Pulumi does not have a dedicated Helm resource for direct Helm operations within the GKE cluster, we will proceed without using the Harness platform. Instead, we will use native Kubernetes resources within Pulumi to showcase the deployment.

Here's a basic program that performs the following:
- Sets up a new GKE cluster.
- Configures the Kubernetes provider to interact with the created cluster.
- Deploys the MongoDB ReplicaSet using the Helm chart.

Keep in mind that this is a basic illustration. In a real-world scenario, you would manage your Helm chart releases more robustly, handle credentials appropriately, and incorporate proper error checking.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("mongo-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    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 new Cluster
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, auth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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`;
    });

// Use a Provider to set up the Helm release once the cluster is available
const clusterProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy a Helm chart for MongoDB ReplicaSet
const mongoDbChart = new k8s.helm.v3.Chart("kanister-mongodb-replicaset", {
    chart: "kanister-mongodb-replicaset",
    version: "0.4.0",
    fetchOpts:{
        repo: "https://charts.kanister.io/",
    },
}, { provider: clusterProvider });

// Export the MongoDB service endpoint
export const mongoDbEndpoint = mongoDbChart.getResource("v1/Service", "kanister-mongodb-replicaset")
    .status
    .apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation:

1. **GKE Cluster Creation**: `google-native.container/v1beta1.Cluster` is used to create a new GKE cluster. This resource takes several parameters to specify the desired state of the cluster, such as the node count and the machine types.

2. **Kubeconfig**: After the cluster is created, we export the kubeconfig which is necessary for the Kubernetes provider to communicate with the cluster. We generate the kubeconfig using the cluster's data.

3. **Kubernetes Provider Configuration**: We instantiate a Pulumi Kubernetes provider that refers to our new GKE cluster using the kubeconfig we exported. This provider is later used by Helm to deploy to the correct cluster.

4. **Helm Chart Deployment**: We then define a `k8s.helm.v3.Chart` resource for deploying the MongoDB ReplicaSet using its Helm chart. We specify the chart name, version, and repository URL. The `provider: clusterProvider` line ensures that the chart is deployed to the GKE cluster we created.

5. **MongoDB Service Endpoint**: Once the Helm chart is deployed, we export an endpoint that can be used to interact with the MongoDB ReplicaSet. We reference the service created by the Helm chart to obtain the IP address.

Remember that Pulumi is an infrastructure as code tool that requires you to have Pulumi CLI installed and configured with the appropriate cloud provider credentials. After setting up and writing this code in a `index.ts` file within a Pulumi project, you can run `pulumi up` to deploy the infrastructure.