Deploy the simple-mssql helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps. First, you will need to create a GKE cluster. Next, you will need to set up the Helm client and install the chart on the cluster. In Pulumi, you can do both of these using TypeScript.

Below, I will provide you with a Pulumi program that creates a GKE cluster and deploys the `simple-mssql` Helm chart to it.

The program uses two main resources:

1. `gcp.container.Cluster`: A resource that creates a GKE cluster. We'll configure it with the necessary settings, but we'll keep it simple for the purpose of this explanation.
2. `kubernetes.helm.v3.Chart`: A resource to deploy the Helm chart to the GKE cluster. This assumes the Helm chart `simple-mssql` is available in a repository.

Before you run this program, make sure Pulumi is installed and your GCP account is properly set up with the right permissions, and that you have authenticated Pulumi with GCP.

Here's the full Pulumi program in TypeScript to accomplish your goal:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    // Define the cluster settings as needed. Adjust the number of nodes, machine type, etc., according to your needs.
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest version of GKE, or specify the version you need.
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Choose the machine type based on your requirements.
        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 Kubeconfig
export 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
`;
    });

// Set up the Kubernetes provider using the generated kubeconfig from the cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig
});

// Install the simple-mssql Helm chart
const mssqlChart = new k8s.helm.v3.Chart("simple-mssql", {
    chart: "simple-mssql",
    fetchOpts: {
        // Specify the repository where the Helm chart is located. Replace with the correct URL for the simple-mssql chart.
        repo: "http://charts.example.com/",
    },
}, { provider: k8sProvider });

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

Let's explain what each part of the code does:

- We start by importing the required modules from Pulumi for GCP and Kubernetes.
- We create a new GKE cluster with a specified number of nodes and the right configurations for OAuth scopes. We specify the `machineType` and cluster versions as well.
- The `kubeconfig` variable constructs the configuration needed to communicate with the created GKE cluster using the cluster's endpoint and the masterAuth data.
- We then create a new Pulumi Kubernetes provider that uses the kubeconfig from the GKE cluster we created. This provider will allow us to deploy Kubernetes resources to our cluster.
- After that, we instantiate the `simple-mssql` Helm chart deployment. We specify where the Helm chart is located using the `fetchOpts.repo`. You need to replace this URL with the actual repository where the `simple-mssql` chart can be found.
- Finally, we export the Helm chart's resources so that we can interact with them outside of Pulumi as needed.

To run this Pulumi program:

1. Save the above code in a file with a `.ts` extension (e.g., `index.ts`).
2. Run `pulumi up` in the terminal in the same directory as the code file.

Pulumi will execute the instructions to create the GKE cluster and deploy the Helm chart. If there are any prompts, you may need to respond to them (typically to confirm the creation of resources). Once completed, you'll be able to see the GKE cluster and Helm deployment in your Google Cloud Console.