Deploy the prometheus-monitoring-stack helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the Prometheus monitoring stack on an OpenShift cluster using Pulumi, you'll need to use the Kubernetes provider with a Helm chart resource. Pulumi's Kubernetes provider allows you to interact with Kubernetes resources, including deploying Helm charts to orchestrate complex applications like Prometheus.

We will be using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider to deploy the Prometheus monitoring stack Helm chart. The Helm chart resource is specifically designed to work with Helm charts, making it straightforward to deploy third-party applications.

Here's a step-by-step guide and the corresponding Pulumi program written in TypeScript to achieve the deployment:

1. **Setting up the Project**: Create a new Pulumi project using your preferred language, which in this case is TypeScript.
2. **Kubernetes Provider**: You will need to install the Kubernetes provider packages for Pulumi; these will enable you to manage Kubernetes resources.
3. **Creating a Helm Chart Resource**: You will define a `kubernetes.helm.v3.Chart` resource in your Pulumi program to deploy the Prometheus monitoring stack.
4. **Configuring the Helm Chart**: You will need to specify the chart name, version, and any custom values that are required for the deployment of the Prometheus stack into your OpenShift cluster.

Make sure that you have your OpenShift cluster's `kubeconfig` file ready and that the Pulumi CLI is set up to use it. This allows Pulumi to authenticate and communicate with your OpenShift cluster to perform deployments.

Now, let's see the code to achieve this:

```typescript
import * as kubernetes from '@pulumi/kubernetes';

// Create an instance of the Kubernetes provider configured for OpenShift.
const openshiftProvider = new kubernetes.Provider('openshift', {
  // Assuming the kubeconfig is set in your environment or Pulumi config
  kubeconfig: process.env.KUBECONFIG,
});

// Deploy the Prometheus monitoring stack using a Helm chart resource.
const prometheusStack = new kubernetes.helm.v3.Chart('prometheus-stack', {
  chart: 'kube-prometheus-stack',
  version: 'x.y.z', // Replace with the version number you wish to deploy
  namespace: 'monitoring', // This is where you want the stack to be deployed within your OpenShift cluster.
  fetchOpts: {
    repo: 'https://prometheus-community.github.io/helm-charts', // This is the repository where the chart can be found.
  },
  // Define any custom values for the Helm chart. For example:
  values: {
    grafana: {
      enabled: true,
    },
    prometheus: {
      service: {
        type: 'ClusterIP',
      },
    },
  },
}, { provider: openshiftProvider });

// Export the Grafana service URL so that it can be accessed easily after deployment
export const grafanaUrl = prometheusStack.getResourceProperty(
  'v1/Service',
  'monitoring/grafana',
  'status',
);

```

In the above program, make sure to replace `'x.y.z'` with the actual version of the `kube-prometheus-stack` Helm chart you wish to deploy. Be sure to check the chart's documentation for the correct version and any specific configuration options you may need for your use case.

The `grafanaUrl` export will provide you with the status of the Grafana service, which is part of the Prometheus Stack, so you can verify its availability after the deployment.

Please note that deploying or managing applications in OpenShift might require you to have specific roles and permissions; make sure you have the required access rights.

Refer to the Pulumi documentation for `kubernetes.helm.v3.Chart` here: [Helm Chart Resource](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/) for more details on using Helm chart resources with Pulumi.