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

Question

Pulumi · Accepted Answer

To deploy the Prometheus Exporter Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we need to accomplish the following steps:

1. **Setup a GKE Cluster**: To host our Prometheus Exporter, we must first ensure that we have an operational Kubernetes cluster on GKE. We will use the `google-native.container.v1.Cluster` resource to create a new Kubernetes cluster on GKE.

2. **Install the Helm Chart**: With the Kubernetes cluster in place, we need to deploy the Prometheus Exporter Helm chart. We will use the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider to install the chart into our GKE cluster.

Here is the TypeScript program that performs these operations:

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

// Initialize GCP provider.
const gcpProvider = new gcp.Provider("gcp", { project: "my-gcp-project" });

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Define your machine type
    },
}, { provider: gcpProvider });

// Export the cluster name and kubeconfig
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:
    client-certificate-data: ${masterAuth.clientCertificate}
    client-key-data: ${masterAuth.clientKey}
    token: ${masterAuth.token}`;
    });

// Create an instance of the Kubernetes provider pointing to the GKE cluster.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy Prometheus Exporter chart using the Helm Chart resource.
const prometheusExporter = new k8s.helm.v3.Chart("prometheus-exporter", {
    chart: "prometheus-community/prometheus",
    fetchOpts:{
        repo: "https://prometheus-community.github.io/helm-charts",
    },
    // Define the values for the Helm chart as needed.
    values: {
        // Your customized values go here.
    },
}, { provider: k8sProvider });

// Export the Prometheus Exporter service URL.
export const prometheusExporterServiceUrl = pulumi.interpolate`http://${prometheusExporter.getResourceProperty("v1/Service", "prometheus-exporter-prometheus-server", "status").apply(status => status.loadBalancer.ingress[0].hostname)}`;
```

### Explanation

1. **Import Required Libraries**: We import the necessary modules from Pulumi's GCP, Kubernetes packages, and general Pulumi library.

2. **Initialize GCP Provider**: We create an instance of the Pulumi GCP provider, specifying the project we're working in. This allows Pulumi to operate within the correct GCP context.

3. **Create GKE Cluster**: We define a `google-native.container.v1.Cluster` resource, with desired configuration settings like node count, master, and node versions. The `machineType` property specifies the type of machine to use for our cluster nodes. The `initialNodeCount` specifies the number of nodes to create in this cluster.

4. **Export Cluster Details**: We export the GKE cluster's name and the kubeconfig required to interact with the cluster through the Kubernetes CLI or other clients. The kubeconfig is created dynamically using the cluster's endpoint and authentication details.

5. **Create Kubernetes Provider**: A Kubernetes provider is configured to communicate with the newly created GKE cluster.

6. **Deploy Helm Chart**: The `kubernetes.helm.v3.Chart` resource is used to deploy the Prometheus Exporter Helm chart from the `prometheus-community` Helm repository. This resource specifies the chart name and optionally the values to customize the deployment.

7. **Export Service URL**: We export the URL of the Prometheus Exporter service which would be created as part of the Helm chart deployment. This allows you to easily access the Prometheus Exporter outside of the cluster.

To apply this Pulumi program, save the code into a file (e.g., `index.ts`), and run `pulumi up` through the CLI. This will prompt Pulumi to perform the deployment as per the defined resources in the program. Make sure Pulumi CLI is installed and configured correctly before running the command.