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

Question

Pulumi · Accepted Answer

To deploy the `prometheus-customizations` helm chart on Google Kubernetes Engine (GKE) using Pulumi, we will follow these steps:

1. Set up a new GKE cluster: To deploy a Helm chart, we first need a Kubernetes cluster where we will install Prometheus. We will create a GKE cluster using the `google-native.container/v1beta1.Cluster` resource, which represents a GKE cluster in Google Cloud.

2. Deploy the Helm chart: Once we have our GKE cluster set up, we will deploy the `prometheus-customizations` helm chart to the cluster. We will use the `kubernetes.helm.v3.Chart` resource, which represents a Helm chart in Pulumi's Kubernetes provider. The exact configuration details for the Helm chart, such as version and custom values, depend on the specifics of `prometheus-customizations`.

Below is a TypeScript program that uses Pulumi to accomplish these 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,
    minMasterVersion: "latest",
    nodeConfig: {
        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"
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig
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 pointing to the GKE cluster.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the prometheus-customizations Helm chart.
const prometheusChart = new k8s.helm.v3.Chart("prometheus", {
    chart: "prometheus",
    version: "YOUR_CHART_VERSION", // Specify the chart version here
    fetchOpts:{
        repo: "https://prometheus-community.github.io/helm-charts",
    },
    values: {
        // You can define any values that you would normally put in a values.yaml file here.
        // Example: service: { type: LoadBalancer }
    },
}, { provider: k8sProvider });

// Export the Helm chart resources
export const prometheusResources = prometheusChart.resources;
```

### Explanation:

1. **Set up a new GKE cluster:**
   - We create a new GKE cluster using `gcp.container.Cluster`. We specify the desired node count and machine type for the nodes. You can adjust these to suit your workload and budget.
   - We also ensure the nodes have the correct OAuth scopes so they can interact with other Google Cloud services.

2. **Kubeconfig:**
   - We then export the kubeconfig that will be used by our Kubernetes provider to interact with the GKE cluster. This configuration contains credentials for the cluster endpoint and a secure way to authenticate using `gcloud`.

3. **Kubernetes Provider:**
   - We create a Pulumi Kubernetes provider that uses the kubeconfig created above. This provider is used to manage the Kubernetes resources in the specified cluster.

4. **Deploy the Helm chart:**
   - We deploy the `prometheus-customizations` Helm chart using `k8s.helm.v3.Chart`. The identity of the chart, typically the repository and chart name, needs to be supplied, along with the version. You must replace `"YOUR_CHART_VERSION"` with the actual chart version you intend to deploy.
   - We use `values` to specify any custom configurations required for your Prometheus setup. These are the same values you would specify in a Helm `values.yaml` file.

5. **Export Resources:**
   - We export the Prometheus resources for ease of monitoring and troubleshooting. These are the actual Kubernetes resources that the Helm chart will create.

When you run this Pulumi program with `pulumi up`, a GKE cluster will be created, and once it's up, the Prometheus Helm chart will be deployed to that cluster. If you need to customize the Prometheus deployment further, you can add or modify the `values` field in the `prometheusChart` definition.