Deploy the telegraf-ds-k3s 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:

1. **Create a GKE Cluster**: This forms the basis of your Kubernetes environment.
2. **Install and Configure Helm on the Cluster**: Helm is a package manager for Kubernetes that simplifies deploying applications.
3. **Deploy the Helm Chart**: This step actually deploys your application (in this case, `telegraf-ds-k3s`) onto the cluster.

We'll need to use Pulumi to create the GKE cluster. Once the cluster is up and running, we can install Helm and deploy the `telegraf-ds-k3s` chart.

We will use the following Pulumi resources:
- `Cluster`: To provision a GKE cluster.
- `Helm`: To deploy the `telegraf-ds-k3s` chart.

Here's how you can accomplish this with Pulumi:

```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,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: "us-central1",
});

// 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 GKE cluster.
const clusterProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the telegraf-ds-k3s Helm chart
const helmChart = new k8s.helm.v3.Chart("telegraf-ds-k3s-chart", {
    chart: "telegraf-ds-k3s",
    version: "1.0.0", // specify the exact chart version
    fetchOpts:{
        repo: "https://helm.repo/url", // replace with the actual Helm repo URL
    },
}, { provider: clusterProvider });

export const chart_name = helmChart.getResourceProperty("v1/Service", "telegraf-ds-k3s", "metadata").name;
```

### Detailed Explanation

- We use the `gcp.container.Cluster` resource to create a new GKE cluster. You can adjust the parameters such as `initialNodeCount` and `location` to fit your needs.

- The `kubeconfig` is exported so `kubectl` and other Kubernetes tools (like Helm) can interact with the new cluster. It retrieves the necessary authentication details from the newly created cluster, which allows the Kubernetes provider to manage resources on the cluste.

- The `k8s.Provider` resource represents our connection to the GKE cluster. We pass the `kubeconfig` we generated earlier to this provider so it knows how to communicate with our GKE cluster.

- Next, we define the Helm chart for `telegraf-ds-k3s` using `k8s.helm.v3.Chart` resource. Replace the `chart` name with the correct chart from your helm repository and specify the repository URL. Set the chart version you wish to deploy.

- Finally, we export the name of the Service created by the Helm chart. This assumes that the Helm chart creates a Service and you may want to replace `"v1/Service"` and `"telegraf-ds-k3s"` with appropriate values from the chart you're deploying.