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

Question

Pulumi · Accepted Answer

Deploying a Prometheus Monitoring Stack on Google Kubernetes Engine (GKE) involves several steps with Pulumi:

1. **Creating a GKE Cluster**: You need a Kubernetes cluster to deploy your Prometheus Stack onto. In this case, we'll use the `google-native.container.v1.Cluster` resource to create a GKE cluster.
2. **Deploying the Helm Chart**: Once the cluster is up and running, you use the Pulumi Kubernetes Provider and its `kubernetes.helm.v3.Chart` resource to deploy the Prometheus Monitoring Stack.

### Step-by-step Code Walkthrough:

1. Import the necessary Pulumi and Kubernetes libraries.
2. Set up the GKE Cluster with the required configurations.
3. Initialize a Kubernetes Provider to interact with the newly created GKE cluster.
4. Deploy the Prometheus Monitoring Stack using Helm chart within the context of our Kubernetes Provider.

Now let's translate this into an actionable Pulumi TypeScript program:

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

// Step 1: Create a new GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Specify a specific version if needed
    nodeVersion: "latest",
    nodeConfig: {
        // You can specify the machine type, disk size, etc.
        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",
        ],
    },
    // Additional settings can be configured as per need
});

// Step 2: Create a Kubernetes Provider instance that uses our GKE cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.endpoint.apply( endpoint => {
        return cluster.name.apply(name => {
            return cluster.masterAuth.apply(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}'`;
            });
        });
    }),
});

// Step 3: Deploy the Prometheus Monitoring Stack Helm chart in our GKE cluster
const prometheusStack = new k8s.helm.v3.Chart("prometheus-monitoring-stack", {
    chart: "prometheus",
    version: "13.0.0", // Use the version of the chart you want to deploy
    fetchOpts: {
        repo: "https://prometheus-community.github.io/helm-charts",
    },
}, { provider: k8sProvider });

// Export the Cluster name and the Kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = k8sProvider.kubeconfig;

// Run `pulumi up` to deploy this stack to GKE and install Prometheus
```

### Explanation:
- **GKE Cluster Creation**: We created a GKE cluster with initial node count set to 2. You can modify the machine type and other parameters based on your needs.
- **Kubernetes Provider**: We set up a Kubernetes provider to interact with the GKE cluster. It uses the `kubeconfig` generated from the cluster's data.
- **Helm Chart Deployment**: We deployed the `prometheus` Helm chart to the GKE cluster by giving a chart name and version. Ensure you have the correct version you need. Here, `13.0.0` is mentioned as an example, and the chart is fetched from the Prometheus community's Helm chart repository.

With this Pulumi program, you can deploy the Prometheus Monitoring Stack to monitor your GKE cluster's performance and health. Run `pulumi up` to execute the deployment. After the deployment, the Prometheus UI will be accessible through the Kubernetes service created by the Helm chart. Remember to set up proper access controls and network policies to ensure the security of your monitoring stack.

You will need to have Pulumi and GCP CLI tools installed, and have the appropriate cloud provider credentials set up on your machine to run this program successfully.