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

Question

Pulumi · Accepted Answer

To deploy the `prometheus-jsonpath-exporter` Helm chart on Google Kubernetes Engine (GKE), you'll need to follow these steps:

1. **Set up a GKE cluster**: First, you'll need to create a GKE cluster if you don't already have one. Pulumi's `@pulumi/gcp` package provides the `Cluster` resource that can be used to create and manage a cluster in GKE.

2. **Install the Helm Chart**: Once your GKE cluster is ready, you'll use Pulumi's `@pulumi/kubernetes` package to install the Helm chart onto your cluster. The `Chart` resource from the `helm.sh/v3` subpackage is specifically designed to manage Helm chart deployments.

Below is a Pulumi program written in TypeScript that accomplishes this. It assumes that you have Pulumi installed, a Pulumi project set up, and that you're authenticated with GCP with the necessary permissions to create and modify GKE clusters and install Helm charts.

Before running this program, it would be wise to familiarize yourself with the basics of Pulumi, GCP, and Helm chart deployment using Pulumi's [Getting Started guides](https://www.pulumi.com/docs/get-started/).

```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("gke-cluster", {
  initialNodeCount: 2,
  nodeConfig: {
    // Choose appropriate machine type for your needs
    machineType: "n1-standard-1"
  },
});

// Export the Cluster name and Kubeconfig to access the cluster with kubectl
export const clusterName = cluster.name;
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
`;
  });

// Initialize a new Kubernetes Provider using the GKE cluster
const k8sProvider = new k8s.Provider("gke-k8s", {
  kubeconfig: kubeConfig,
});

// Deploy Prometheus Jsonpath Exporter Helm chart
const chart = new k8s.helm.v3.Chart("prometheus-jsonpath-exporter", {
  chart: "prometheus-jsonpath-exporter",
  version: "0.2.0", // specify the version of the chart you want to deploy
  fetchOpts: {
    repo: "https://your-helm-chart-repository" // replace with the URL of the chart's repository
  },
}, { provider: k8sProvider });

// Export the Service URL to access Prometheus Jsonpath Exporter
export const prometheusExporterServiceUrl = chart.getResourceProperty("v1/Service", "prometheus-jsonpath-exporter", "status")
  .apply(status => status.loadBalancer.ingress[0].ip);
```

Here's what each part of this program is doing:

- **GKE Cluster**: We create a GKE cluster with a default number of 2 nodes and a standard machine type `n1-standard-1`. You can adjust the node count and machine type according to your own requirements.

- **Kubeconfig**: We build the kubeconfig needed to access the cluster using `kubectl`. This configuration will be used by Pulumi's Kubernetes provider.

- **Kubernetes Provider**: We initialize the Kubernetes provider and use the kubeconfig from our cluster. This provider will help manage resources on the cluster.

- **Helm Chart**: Using the Kubernetes provider, we deploy the `prometheus-jsonpath-exporter` Helm chart onto the GKE cluster. Make sure to replace `"https://your-helm-chart-repository"` with the actual repository where the Helm chart is located. You will also need to specify the version you wish to deploy.

- **Service URL Export**: Finally, we export the service URL which you can use to access the `prometheus-jsonpath-exporter`. The LoadBalancer IP is fetched from the service status once it's ready.

After writing this Pulumi program, you can run it with the following commands in your CLI:

```bash
pulumi up # Preview and deploy changes
```

This command will provision the cluster, deploy the Helm chart, and output the Service URL. If you need to access your Kubernetes cluster with `kubectl`, you can use the kubeconfig we exported.

Remember, if the Helm chart is hosted in a private repository, you will need to configure access credentials accordingly. Additionally, if the chart has custom values you wish to specify, you can pass a `values` map to the `Chart` resource.