Deploy the kubernetes-dashboard-1-7 helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Kubernetes Dashboard version 1.7 using a Helm chart on Google Kubernetes Engine (GKE), you will first need to set up a GKE cluster where the Dashboard will run. Then, you will deploy the Helm chart for the Kubernetes Dashboard onto the GKE cluster.

Pulumi provides the `kubernetes.helm.v3.Chart` resource which allows you to deploy Helm charts easily into a Kubernetes cluster. Helm charts are collections of pre-configured Kubernetes resources that you can deploy as a unit.

Here is a program that creates a GKE cluster and deploys a Helm chart for Kubernetes Dashboard version 1.7:

```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("gke-cluster", {
    initialNodeCount: 2,
    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;

// Export the Kubeconfig to access the cluster with kubectl
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: ${context}
`;
    });

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

// Deploy the Kubernetes Dashboard using a Helm Chart
const dashboard = new k8s.helm.v3.Chart(
    "kubernetes-dashboard",
    {
        namespace: "kube-system",
        chart: "kubernetes-dashboard",
        version: "1.7.1",
        fetchOpts: {
            repo: "https://kubernetes.github.io/dashboard/",
        },
    },
    { provider: k8sProvider },
);

// Export the Dashboard URL
export const dashboardUrl = pulumi.interpolate`https://${cluster.endpoint}/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/`;

// Important links:
// - GCP Cluster: https://www.pulumi.com/registry/packages/gcp/api-docs/container/cluster/
// - Kubernetes Provider: https://www.pulumi.com/registry/packages/kubernetes/api-docs/provider/
// - Helm Chart: https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/
```

In this program, we first import the required Pulumi packages. We then define a `gcp.container.Cluster`, which represents a GKE cluster where your Kubernetes Dashboard will live. The GKE cluster is configured with two nodes and uses the `n1-standard-1` machine type. The necessary OAuth scopes for the GKE nodes are also specified.

Once the cluster is set up, we generate a `kubeconfig` file allowing us to interact with the cluster using tools like `kubectl`. We store this configuration in a Pulumi output variable.

Next, we create a `k8s.Provider` configured with our `kubeconfig`. This provider will enable communication with the GKE cluster where the Kubernetes Dashboard will be deployed.

We then go on to create a new Helm chart using `k8s.helm.v3.Chart` and specify the desired namespace, the chart name (Kubernetes Dashboard), and its version. We also set the Helm repository where the chart can be found.

Finally, we export the URL that you can use to access the Kubernetes Dashboard through a proxy in the `kube-system` namespace of your GKE cluster. This URL can be used to access the Dashboard once all resources have been provisioned on GKE.

Keep in mind that you will need to set up Pulumi with the appropriate credentials for Google Cloud and have access to any billing account if this is a new GKE cluster provisioning. You might also need to install Helm locally and configure it with proper role-based access control (RBAC) permissions depending on your requirements.