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

Question

Pulumi · Accepted Answer

To deploy the `ozwdaemon` Helm chart on Google Kubernetes Engine (GKE), you will need to perform a series of steps. First, you'll create a GKE cluster, then you'll install Helm and use it to deploy the `ozwdaemon` chart to your cluster. I will guide you through the process using Pulumi with TypeScript.

Here's a step-by-step walkthrough of what you need to do:

1. **Setting up GKE Cluster**: We use the `gcp.container.Cluster` resource from Pulumi's GCP package to set up a new Kubernetes cluster on GKE. We define the necessary properties such as the desired location for the cluster and node count.

2. **Configuring K8s Provider**: Once the cluster is up and running, we need to configure the Pulumi Kubernetes provider to target our newly created GKE cluster. We fetch the cluster’s kubeconfig for this purpose.

3. **Installing Helm and Deploying the Chart**: Helm is a package manager for Kubernetes, which allows us to deploy an application packaged as a Helm chart. We use Pulumi's `kubernetes.helm.v3.Chart` resource to deploy the `ozwdaemon` chart onto our GKE cluster.

Let's start by installing the necessary Pulumi packages using npm:

```bash
npm install @pulumi/gcp @pulumi/kubernetes
```

Now, you can use the following Pulumi program to create your GKE cluster and deploy the `ozwdaemon` Helm chart:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("ozwdaemon-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: "us-central1-a",
    nodeConfig: {
        preemptible: true,
        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 Kubernetes cluster name.
export const clusterName = cluster.name;

// Export the Kubeconfig so that the Kubernetes provider can use it.
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 that uses our kubeconfig.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the ozwdaemon Helm chart
const ozwdaemonChart = new kubernetes.helm.v3.Chart("ozwdaemon", {
    chart: "ozwdaemon",
    fetchOpts:{
        repo: "https://openzwave.github.io/openzwave-helm/",
    },
    // Specify the values for the Helm chart here; you can customize the Helm chart settings as needed.
    values: {
        // Add your desired chart values here
    },
}, { provider: k8sProvider });

// Export the chart's public service endpoint.
export const ozwdaemonEndpoint = pulumi.interpolate`https://${ozwdaemonChart.getResourceProperty("v1/Service", "ozwdaemon", "status").loadBalancer.ingress[0].ip}`;
```

In the above code:

- The `gcp.container.Cluster` creates a new GKE cluster. You may want to change the number of nodes, machine type, and location to fit your need.
- The `kubeconfig` is generated from the cluster information. This kubeconfig is required to authenticate kubectl and the Pulumi Kubernetes provider to your GKE cluster.
- The `kubernetes.Provider` is set up with the aforementioned kubeconfig, allowing Pulumi to manage resources in your GKE cluster.
- The `kubernetes.helm.v3.Chart` resource is used to deploy the `ozwdaemon` chart from its Helm repository. You should specify the `values` field according to your needs to configure the OzW Daemon.
- Finally, an endpoint is exported, which allows you to access the `ozwdaemon` service outside your cluster, if the chart exposes one.

To deploy this Pulumi program:

1. Ensure you’ve set up Pulumi and authenticated with Google Cloud.
2. Run `pulumi up` to create the GKE cluster and deploy the Helm chart.

Please replace the placeholders and chart values with the configuration appropriate for your use case. Note that deploying and managing Kubernetes clusters incurs costs in the cloud provider.