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

Question

Pulumi · Accepted Answer

To deploy the `prometheus-alerts` helm chart on Google Kubernetes Engine (GKE) using Pulumi, you would follow these steps:

1. **Set up the GKE cluster**: A GKE cluster is required to deploy Helm charts onto it. If you don't already have one, you'll need to create a new GKE cluster using Pulumi.

2. **Deploy the Helm Chart**: Once the GKE cluster is ready, you'll deploy the `prometheus-alerts` helm chart using Pulumi by referencing the chart from a Helm repository or by specifying the chart's location in your configuration.

Below is a Pulumi TypeScript program that demonstrates both steps. First, it creates a GKE cluster. Then, it deploys a generic Helm chart, which you need to modify with the location and version of your `prometheus-alerts` Helm chart. Ensure you have the `@pulumi/kubernetes` and `@pulumi/gcp` packages installed in your project to use Kubernetes and GCP resources.

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

// Create a new GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Adjust machine type as needed
        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;

// Manufacture a kubeconfig for the GKE cluster.
// This kubeconfig is used by Pulumi to deploy the Helm chart to the 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 that uses our cluster from above.
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the prometheus-alerts Helm chart
const chart = new k8s.helm.v3.Chart("prometheus-alerts", {
    chart: "prometheus-alerts", // Replace with the correct chart name
    version: "x.x.x", // Replace with the correct chart version
    // Add the repository or define the local path to the chart.
    // If using a remote repository, use `fetchOpts` to specify the repo.
    fetchOpts: {
        repo: "https://prometheus-community.github.io/helm-charts", // Replace with the chart's repository URL
    },
}, { provider: k8sProvider });

// Export the Helm chart name
export const chartName = chart.name;
```

### Explanation:
- `gcp.container.Cluster`: This resource is used to create a GKE cluster where your Helm charts will be deployed.
- `kubeconfig`: This output represents the configuration needed for `kubectl` and other Kubernetes tools to connect to your GKE cluster.
- `k8s.Provider`: This resource is needed for Pulumi to communicate with your Kubernetes cluster and use that context to deploy Helm charts or other Kubernetes resources.
- `k8s.helm.v3.Chart`: This resource allows Pulumi to deploy Helm charts. You specify the chart name and version you want to install.

Please ensure the chart name and version are correctly specified. If your `prometheus-alerts` Helm chart is located in a different repository or a local path, make sure you update the `chart`, `version`, and `fetchOpts.repo` accordingly. If the chart is locally available, you don't need `fetchOpts`, and you should specify the chart's local path instead.

Remember to install the necessary Pulumi packages before running the script:

```sh
npm install @pulumi/pulumi @pulumi/kubernetes @pulumi/gcp
```

Run this program using the Pulumi CLI:

```sh
pulumi up
```

This will provision the GKE cluster and deploy the Prometheus Alerts Helm chart to the cluster.