Deploy the daemonset helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a DaemonSet Helm chart on Google Kubernetes Engine (GKE), you'll need to create a GKE cluster and then use the Helm chart to deploy your DaemonSet. A Helm chart is a package that contains all the required resources and configurations to deploy an application or service on a Kubernetes cluster.

Here's how you can accomplish that using Pulumi and TypeScript:

1. **Create a GKE cluster**: Using the `gcp.container.Cluster` resource, you can create a new GKE cluster. This cluster will be the foundation where your Helm chart will be deployed.

2. **Install the Helm chart**: Once the cluster is created, you can deploy Helm charts using the `helm.v3.Chart` resource provided by Pulumi's Kubernetes provider. This resource will ensure that the specified Helm chart is installed onto your cluster.

### Step-by-step Code Explanation and Pulumi Program

First, let's set up a GKE cluster. Specify the necessary properties like the name, location, node counts, etc. Adjust these settings based on your requirements for the Kubernetes cluster.

```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", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: "us-central1",
    nodeConfig: {
        machineType: "n1-standard-1", // or another machine type
        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;
```

Once the cluster is set up, configure the Kubernetes provider to communicate with the GKE cluster. This configuration will extract the cluster's credentials to enable Pulumi to perform operations on the cluster using Kubernetes' API.

```typescript
// Obtain the Kubeconfig for the GKE cluster.
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 k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});
```

With the GKE cluster running and the Kubernetes provider configured, you can now deploy your DaemonSet Helm chart. You will need the Helm chart's repository URL and the chart name. If the chart has configurable parameters, you can specify them in `values`.

```typescript
// Deploy a Helm chart for the DaemonSet.
const daemonsetChart = new k8s.helm.v3.Chart("my-daemonset", {
    chart: "my-daemonset",
    version: "1.0.0", // specify the chart version
    fetchOpts: {
        repo: "http://my-helm-repo/", // replace with the Helm chart's repository URL
    },
    values: {
        // specify your values here
    },
}, { provider: k8sProvider });

// Export the DaemonSet status for easy access to the service.
export const daemonsetStatus = daemonsetChart.status;
```

Remember to replace `"http://my-helm-repo/"` with the actual Helm chart repository URL and adjust the `chart`, `version`, and `values` fields to fit your DaemonSet Helm chart's specifications. Once deployed, your DaemonSet should be running on all nodes in your GKE cluster.

This completes the configuration and deployment. You can run this Pulumi program with the Pulumi CLI by simply navigating to the directory where this code is saved and running `pulumi up`. Ensure that you have authenticated with GCP and have set appropriate permissions to create GKE clusters.