Deploy the turbonomic-importer helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `turbonomic-importer` Helm chart on Google Kubernetes Engine (GKE), you'll first need to set up a GKE cluster, and then use Pulumi to deploy the Helm chart to that cluster.

Here's a step-by-step guide and Pulumi TypeScript program to achieve this:

### Step 1: Create a GKE Cluster
To deploy workloads on GKE, you must have a cluster. In Pulumi, we use the `gcp.container.Cluster` resource to create a new cluster.

### Step 2: Configure Kubeconfig
Once the cluster is created, we need to configure kubectl with the appropriate credentials to connect to our new GKE cluster. Pulumi provides a way to fetch the raw kubeconfig from the managed GKE cluster which we can use to set up our kubectl configuration.

### Step 3: Deploy Helm Chart
After setting up the connection to the GKE cluster, we will deploy the `turbonomic-importer` Helm chart. The `kubernetes.helm.v3.Chart` resource from Pulumi Kubernetes SDK allows us to deploy a Helm chart to the cluster.

Let's put it all together:

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

const projectName = pulumi.getProject();
const config = new pulumi.Config();

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster('gke-cluster', {
    initialNodeCount: 3,
    nodeVersion: 'latest',
    minMasterVersion: '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;

// Step 2: Configure Kubeconfig
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
`;
    });

// Export the Kubeconfig
export const kubeConfig = kubeconfig;

// Step 3: Deploy the Helm chart
const turbonomicImporterChart = new k8s.helm.v3.Chart('turbonomic-importer', {
    chart: 'turbonomic-importer',
    fetchOpts:{
        repo: 'https://charts.turbonomic.com/charts', // Replace with the actual repo URL if different
    },
}, { provider: new k8s.Provider('gke-k8s-provider', { kubeconfig }) });

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

### Explanation of the Pulumi Program:
- We import the required packages from Pulumi to interact with GCP and Kubernetes.
- We create a GKE cluster with `gcp.container.Cluster`, specifying the machine type and OAuth scopes required by the nodes.
- We then export the cluster name for reference.
- We construct the kubeconfig needed to authenticate kubectl commands against our GKE cluster.
- Next, we export the kubeconfig, which can be used to set up the kubectl context outside of Pulumi if necessary.
- Finally, we use the `k8s.helm.v3.Chart` to deploy the `turbonomic-importer` Helm chart from the specified Helm chart repository to our GKE cluster.

### What Does This Pulumi Program Do?
This program automates the entire process of provisioning a GKE cluster and deploying a Helm chart to it. It does this by defining desired state configurations for the cluster and Helm deployment. When `pulumi up` is executed, Pulumi understands what cloud resources it needs to create or modify to achieve the desired state.

### Next Steps:
After writing the Pulumi program:

1. You should install the Pulumi CLI and authenticate with your GCP account.
2. Run `pulumi up` within the directory where this program resides to preview and deploy the changes.
3. Monitor the output for the cluster name and kubeconfig.

Please ensure that the Helm chart name 'turbonomic-importer' and the repository URL are correct. If they differ, replace them with the correct values.