Deploy the ebpf-exporter helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `ebpf-exporter` Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you will need to perform a few key steps:

1. Set up a GKE cluster.
2. Configure Pulumi to use the Helm package.
3. Deploy the `ebpf-exporter` Helm chart to the GKE cluster.

Below is a Pulumi program in TypeScript that demonstrates how to accomplish this. It assumes that you have already set up and authenticated the Pulumi CLI with appropriate GCP credentials. Moreover, it assumes you have the `pulumi` and `@pulumi/gcp` NPM packages installed.

Firstly, we set up a GKE cluster by creating an instance of `gcp.container.Cluster`. Next, we use `@pulumi/kubernetes` to interact with the Kubernetes API, including deploying Helm charts.

Here's the full program:

```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("ebpf-exporter-cluster", {
    initialNodeCount: 2,
    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 GKE 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: gcp
`;
    });

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

// Deploy the ebpf-exporter Helm chart into the GKE cluster.
const ebpfExporterChart = new k8s.helm.v3.Chart("ebpf-exporter", {
    chart: "ebpf-exporter",
    version: "YOUR-CHART-VERSION", // specify the version of the chart
    fetchOpts:{
        repo: "https://YOUR_HELM_CHART_REPOSITORY", // specify the Helm chart repository
    },
}, { provider: clusterProvider });

// Export the ebpf-exporter Helm chart deployment's status.
export const ebpfExporterStatus = ebpfExporterChart.status;
```

In this program:

- We create a GKE cluster with basic settings: 2 nodes of type `n1-standard-1`. Adjust the size and type of the node pool to suit your workload and budget. The OAuth scopes provided are standard for GKE and give the nodes access to other Google Cloud services.

- The kubeconfig is generated so you can use it with `kubectl` if you need to interact with your GKE cluster directly.

- We instantiate a Kubernetes provider pointing to our newly created GKE cluster. We use this provider when deploying the `ebpf-exporter` chart to ensure the chart is installed into the right cluster.

- Next, we deploy the `ebpf-exporter` Helm chart, specifying the chart's version and the repository where it's located. Please replace `YOUR-CHART-VERSION` with the version of the `ebpf-exporter` chart you want to install and `https://YOUR_HELM_CHART_REPOSITORY` with the URL to the chart's repository.

Make sure to replace placeholders such as `YOUR-CHART-VERSION` and `https://YOUR_HELM_CHART_REPOSITORY` with actual values based on the chart you wish to deploy. The versions and URL can change over time, so it's crucial to refer to the official `ebpf-exporter` Helm chart documentation for the correct details.

After the Pulumi program is ready, deploy it via the Pulumi CLI:

```shell
pulumi up
```

This will provision the GKE cluster and deploy the ebpf-exporter Helm chart as specified in your program, enabling you to use eBPF for observability functions on your Kubernetes cluster.