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

Question

Pulumi · Accepted Answer

To deploy the Prometheus Alertmanager Helm chart on Google Kubernetes Engine (GKE), you will need to perform the following steps:

1. Create a GKE cluster.
2. Install and configure Helm on your local machine to interact with the Kubernetes cluster.
3. Use Helm to deploy the Prometheus-Alertmanager chart on the GKE cluster.

We'll use Pulumi to create a GKE cluster which is managed by Google's Kubernetes Engine service that allows you to run and manage Docker containers and container-based applications on a cluster of Google Cloud instances.

Next, I'll show you a TypeScript program using Pulumi that creates a GKE cluster and installs the Prometheus-Alertmanager Helm chart into this cluster. We'll be using the `@pulumi/gcp` and `@pulumi/kubernetes` packages to create the resources.

Firstly, ensure you have Pulumi installed and configured for use with your GCP account. You should also have `kubectl` installed to interact with your Kubernetes cluster and Helm to manage Kubernetes applications.

Here's the Pulumi program:

```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("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        preemptible: true,
        machineType: "e2-medium",
        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 Cluster endpoint to use 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 k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: kubeconfig,
});

// Use Helm to deploy the Prometheus Alertmanager chart
const prometheusAlertmanager = new k8s.helm.v3.Chart("prometheus-alertmanager", {
    chart: "prometheus-alertmanager",
    version: "x.y.z", // specify the version you want to deploy
    fetchOpts: {
        repo: "https://prometheus-community.github.io/helm-charts",
    },
}, { provider: k8sProvider });

// Export the status of the Helm deployment
export const alertmanagerStatus = prometheusAlertmanager.status;
```

Make sure to replace `x.y.z` with the version of the `prometheus-alertmanager` chart you wish to deploy. You can find the chart version from the Prometheus community Helm repository or whichever repository the chart is in.

**Explanation**:

- We start by importing the necessary Pulumi packages for GCP and Kubernetes.
- Next, we create a GKE cluster with specifications that we assign in `gcp.container.Cluster`.
- We export `clusterName` and `kubeconfig`. The `kubeconfig` is required for `kubectl` to connect to the new cluster, and we include it so you can also interact with the cluster without Pulumi.
- We create a Pulumi Kubernetes provider that will point to the newly created GKE cluster.
- Then, we create an instance of the `k8s.helm.v3.Chart` class, which will install the Prometheus-Alertmanager Helm chart from the provided repository.
- Finally, we export the status of the Helm deployment, which you can use to inspect the state of the deployed chart.

This program assumes that you have the necessary IAM permissions to create GKE clusters and deploy to them set up in your GCP account. You also need to have Helm installed locally if you want to interact with the Helm charts directly.

Run the program by navigating to the directory containing this code and executing `pulumi up`. Pulumi will then perform the necessary actions to create a GKE cluster and deploy the Prometheus-Alertmanager Helm chart onto it.