Deploy the ibm-galera-mariadb-dev helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy an IBM Galera MariaDB development Helm chart on Google Kubernetes Engine (GKE) with Pulumi, you need to follow these steps:

1. **Set up a GKE Cluster**: Before deploying the Helm chart, you need a Kubernetes cluster. Pulumi can provision a new GKE cluster or use an existing one.
2. **Install Helm**: Ensure that Helm is installed on your local machine or wherever Pulumi will be executed, as Pulumi will use the Helm CLI to deploy the chart to the cluster.
3. **Add the IBM Helm Chart Repository**: The IBM Helm chart repository must be added to Helm on the machine executing Pulumi so it knows where to find the `ibm-galera-mariadb-dev` chart.
4. **Deploy the Helm Chart**: Once the cluster is up and Helm is configured, deploy the Helm chart to the cluster using Pulumi.

Below is a Pulumi TypeScript program that demonstrates how to carry out these steps:

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

// Step 1: Provision a new GKE cluster
const cluster = new gcp.container.Cluster("galera-mariadb-cluster", {
    initialNodeCount: 3,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Adjust the machine type based on your needs
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Obtain the Kubeconfig for the newly created Cluster
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth[0].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: Use the GKE cluster as the provider for the Helm release
const clusterProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Helm Chart deployment of IBM Galera MariaDB
const chart = new k8s.helm.v3.Chart("galera-mariadb-dev", {
    chart: "ibm-galera-mariadb-dev",
    version: "specific version", // specify the version you want to deploy
    fetchOpts: {
        repo: "https://charts.cloud.ibm.com/ibm/index.yaml", // The IBM Helm chart repository URL
    },
}, { provider: clusterProvider });

// Export the Helm chart name
export const chartName = chart.name;
```

This program completes these tasks:

- **Provisions a GKE Cluster**: Using the `@pulumi/gcp` module, a new GKE cluster is created with an initial node count. The machine type and version of the cluster nodes can be modified as per requirement.
- **GKE Cluster Kubeconfig**: It generates the kubeconfig needed to interact with the cluster, which is then used to set up a Pulumi Kubernetes provider.
- **Kubernetes Provider**: The Kubernetes provider allows Pulumi to perform actions on the Kubernetes cluster that we provisioned.
- **Helm Chart**: It deploys the `ibm-galera-mariadb-dev` Helm chart from IBM's Helm chart repository using the Kubernetes provider configured with the cluster's kubeconfig.

To run the above program, you need to install Pulumi and configure it for use with Google Cloud. You need `gcloud`, `kubectl`, and `helm` CLI tools installed. The program should be run in a directory with a valid Pulumi project, and you should have authenticated `gcloud` with your GCP account credentials.

After running this Pulumi program, you should have a running instance of IBM Galera MariaDB on your GKE cluster, which you can manage using `kubectl` or additional Pulumi programs. Remember to customize the version and other configuration options of the Helm chart as necessary for your deployment requirements.