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

Question

Pulumi · Accepted Answer

To deploy a Prometheus-target Helm chart on Google Kubernetes Engine (GKE), we need to perform several steps:

1. **Setup a GKE Cluster**: We will define a GKE cluster resource using Pulumi's GCP integration.
2. **Install the Helm Chart**: Once the cluster is provisioned, we will use Pulumi's Kubernetes provider to deploy the Prometheus-target Helm chart to the cluster.

Below is a detailed Pulumi program written in TypeScript to accomplish this. Make sure you have Pulumi installed, configured, and authenticated with your Google Cloud account.

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

// Define the GKE cluster configuration
const cluster = new gcp.container.Cluster("my-gke-cluster", {
  initialNodeCount: 2,
  nodeVersion: "latest",
  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 and Kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = cluster.endpoint.apply(endpoint =>
  cluster.name.apply(name =>
    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}'
      name: gcp
`;
    })
  )
);

// Create a Kubernetes Provider instance using the exported kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
  kubeconfig: kubeconfig,
});

// Deploy the Prometheus-target Helm chart
const prometheusChart = new k8s.helm.v3.Chart("prometheus-target", {
  chart: "prometheus",
  version: "13.0.0", // Specify the version of the chart you want to deploy
  fetchOpts: {
    repo: "https://prometheus-community.github.io/helm-charts",
  },
}, { provider: k8sProvider });

// Export the Prometheus Helm chart status and endpoint
export const prometheusStatus = prometheusChart.status;
export const prometheusEndpoint = prometheusChart.getResourceProperty("v1/Service", "prometheus-target-server", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's go through the code:

1. We import the necessary Pulumi libraries for GCP and Kubernetes.
2. We create a GKE cluster with the specified machine type and OAuth scopes necessary for GKE nodes to interact with Google Cloud services.
3. We export both the cluster name and the generated kubeconfig. This kubeconfig will be used by Pulumi to interact with the GKE cluster.
4. We create a Kubernetes Provider instance that configures Pulumi to use the kubeconfig for deploying resources to our newly-created cluster.
5. We declare the Prometheus Helm chart with its version and repository, and we associate it with our Kubernetes provider.
6. Lastly, we export the status of the deployed Helm chart and the endpoint of the Prometheus service, which can be used to access the Prometheus web UI once it's deployed.

Keep in mind that `prometheus` and `13.0.0` used in the `Chart` resource are placeholders, and you might need to change the chart name to `prometheus-target` and use the appropriate version that suits your needs. You'd replace these placeholders with the exact chart name and the version you want to deploy.

To apply this Pulumi code:

1. Save the code in a file named `index.ts` in a new directory.
2. Run `pulumi up` from within that directory to create the resources. This command will prompt you for confirmation before applying the changes.

After successful deployment, you'll get the Prometheus endpoint as an output. You can use this IP address to access the Prometheus web UI.