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

Question

Pulumi · Accepted Answer

To deploy the `prometheus-process-exporter` Helm chart on Google Kubernetes Engine (GKE), we need to perform the following steps:

1. **Set up a GKE cluster**: First, we need to provision a GKE cluster where our applications will run. We will use the `gcp.container.Cluster` resource to create a new Kubernetes cluster.

2. **Install the Helm Chart**: After setting up the GKE cluster, we'll utilize the `kubernetes.helm.v3.Chart` resource to deploy the `prometheus-process-exporter` chart from its repository. This resource is responsible for fetching and installing Helm charts into a Kubernetes cluster.

Below is a TypeScript program that demonstrates how to accomplish these tasks using Pulumi.

### Pulumi Program Explained

- **Imports**: We start by importing the necessary libraries for GCP, Pulumi Kubernetes, and Helm.
- **Cluster Creation**: We instantiate a GKE cluster with the specified configuration such as the initial node count and machine type.
- **KubeConfig**: We retrieve the kubeconfig from the GKE cluster to communicate with the cluster.
- **Helm Chart Installation**: Finally, we deploy the `prometheus-process-exporter` Helm chart into the GKE cluster using the retrieved kubeconfig.

Here's the complete Pulumi TypeScript program that encapsulates the above steps:

```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('gke-cluster', {
    initialNodeCount: 2,
    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'
        ],
    },
});

// Retrieve the kubeconfig for the created GKE cluster
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 using the kubeconfig
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeconfig,
});

// Deploy the `prometheus-process-exporter` Helm chart on the cluster
const prometheusProcessExporterChart = new k8s.helm.v3.Chart('prometheus-process-exporter', {
    chart: 'prometheus-process-exporter',
    version: '0.1.0',
    fetchOpts: {
        repo: 'https://prometheus-community.github.io/helm-charts',
    },
}, { provider: k8sProvider });

// Export the cluster's name and kubeconfig
export const clusterName = cluster.name;
export const clusterKubeconfig = kubeconfig;
```

This program configures a GKE cluster and deploys the `prometheus-process-exporter` Helm chart. The version `0.1.0` in the `Chart` resource specifies the version of the Helm chart to be used and can be modified as per the requirements. Similarly, the `nodeConfig` can be customized to suit the specific needs of your workload.

Make sure you have Pulumi installed and configured with GCP credentials. You should also have `gcloud` CLI installed as the `kubeconfig` generated references `gcloud` for command execution. To run this program, save it to a file named `index.ts`, then run `pulumi up` to create the resources. After the command successfully completes, your GKE cluster will be up and running with the `prometheus-process-exporter` Helm chart installed.