Deploy the kube-azure helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to a Google Kubernetes Engine (GKE) cluster involves several steps which include creating the GKE cluster, setting up Helm, and deploying the chart.

Below, I'll walk you through the process in Pulumi using TypeScript.

### Overview of the Process and Resources Used

1. **Create a GKE cluster**: We'll use the `gcp.container.Cluster` resource to provision a new GKE cluster. We choose `gcp` over `google-native` for its simplified interface and ease of use.

2. **Install Helm on the cluster**: For this, we'll use a Kubernetes provider configured to point to the newly created GKE cluster.

3. **Deploy the Helm chart**: Using Pulumi's `helm.v3.Chart` resource, we'll deploy the `kube-azure` Helm chart to the GKE cluster. The `kube-azure` chart is a hypothetical example and might not exist. You would replace it with the actual Helm chart you want to install.

### Prerequisites
Make sure you have the following prerequisites set up:

- Pulumi CLI installed and authenticated.
- Access to a GCP project with the necessary permissions to create a GKE cluster.
- GCP credentials file configured with appropriate permissions.

### Detailed Program Explained

The following program will:

- Import necessary modules and initialize Pulumi configuration.
- Create a GKE cluster.
- Configure the Kubernetes provider to use the newly created GKE cluster credentials.
- Deploy the Helm chart to the cluster.

Now, let's create the Pulumi program:

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

// Step 1: Create the GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        preemptible: true, // Use preemptible VMs for cost-saving if appropriate
        machineType: "n1-standard-1", // Choose the machine type based on your requirements
    },
});

// Step 2: Configure Kubernetes provider to use the GKE cluster credentials
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Step 3: Deploy the kube-azure Helm chart on the GKE cluster
const helmChart = new helm.v3.Chart("kube-azure", {
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the actual Helm chart repository
    },
    chart: "kube-azure", // Replace with the actual Helm chart name
    version: "1.0.0", // Replace with the Helm chart version you want to deploy
}, { provider: k8sProvider });

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

// Optional: Export the Helm chart deployment status
export const helmChartStatus = helmChart.status;
```

### Explanation:

- `gcp.container.Cluster`: This creates a new GKE cluster with two nodes of type "n1-standard-1". We've also enabled preemptible instances for cost savings. You need to replace these with more suitable values depending on your use case and workload requirements.

- `k8s.Provider`: This resource represents a Kubernetes provider that Pulumi uses to interact with the cluster. It uses the raw kubeconfig output from the cluster to authenticate.

- `helm.v3.Chart`: This resource represents a Helm chart to deploy. We provide the chart name, version, and the repository where the chart can be found. Note that the `kube-azure` chart is an example, and you should replace this with the real chart name you intend to deploy.

- `export`: In the end, we are exporting the cluster name and the Helm chart deployment status. These can be helpful for referencing the cluster or chart in further operations and for debugging any issues that might arise.

Remember, when running this code with Pulumi, you will be prompted to confirm the deployment after running `pulumi up`, allowing you to see a preview of the resources that will be created. After confirmation, Pulumi will proceed to create the resources and apply the Helm chart.