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

Question

Pulumi · Accepted Answer

To deploy the kube-dns helm chart on Google Kubernetes Engine (GKE), you will need to follow several steps:

1. Set up a GKE cluster if you don't have one already.
2. Install Helm if it's not already set up in your environment.
3. Use Helm to deploy the kube-dns chart onto your GKE cluster.

Below is a Pulumi program written in TypeScript that carries out these steps. It assumes you have the necessary permissions and have authenticated with GCP and Pulumi CLI.

The Pulumi program is divided into sections:
- **GKE Cluster Setup**: This creates a GKE cluster using the `gcp.container.Cluster` resource.
- **Helm Chart Deployment**: After the cluster is set up, we move on to installing the kube-dns Helm chart using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider, which wraps Helm functionality.

This program will create a GKE cluster and deploy the kube-dns Helm chart to it. Make sure you have Helm installed locally, as Pulumi will invoke the local Helm CLI to deploy the chart.

Let's start with the code.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-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 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
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const clusterProvider = new k8s.Provider("my-gke-provider", {
    kubeconfig: kubeconfig,
});

// Deploy kube-dns Helm chart
const kubeDnsChart = new k8s.helm.v3.Chart("kube-dns", {
    chart: "kube-dns", // Set the name of the Helm chart you want to install
    // Specify the helm repository where your chart is hosted
    // Replace with valid repository for kube-dns if different
    fetchOpts:{
        repo: "http://kubernetes-charts.storage.googleapis.com/",
    },
    // Optionally, you can specify chart values
    values: {
        // example value: specify the number of replicas
        replicas: 2,
    },
}, { provider: clusterProvider });

// Export the Chart name
export const chartName = kubeDnsChart.metadata.name;

// When running this program, Pulumi will invoke the Helm CLI to deploy the chart,
// in addition to creating and managing the GKE cluster with the specified configuration.
```

### Explanation

**GKE Cluster Setup:**
- `initialNodeCount` specifies the number of nodes to start within the cluster.
- `minMasterVersion` and `nodeVersion` ensure you're using the latest versions of GKE and node for your cluster.
- `nodeConfig` sets up the type of node and the OAuth scopes necessary for the GKE nodes to function correctly.

**Helm Chart Deployment:**
- A new Kubernetes provider (`clusterProvider`) is initialized with the kubeconfig from the created GKE cluster.
- The `kube-dns` Helm chart is deployed using that provider.
- `fetchOpts.repo` is set to the repository URL where the kube-dns chart can be found. Make sure to replace this with the correct repository URL if it's different.
- `values` is an object that can be provided to configure the chart on deployment. I've shown an example of how to set the number of replicas.

Finally, we export the Kubernetes cluster's `kubeconfig` and the Helm chart's name for easy access.

You should replace placeholder values such as the chart repository URL with actual values that apply to your setup. Ensure your local machine has `kubectl` and Helm installed and configured properly to interact with your Kubernetes cluster.

To use this program, save it as `index.ts`, install the necessary Pulumi packages using `npm` or `yarn`, and then run `pulumi up` to create the GKE cluster and deploy the kube-dns Helm chart.