Deploy the prometheus-alertmanager helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Prometheus Alertmanager on an Azure Managed OpenShift service using Pulumi, we will go through the following steps:

1. **Set up the Managed OpenShift Cluster**: We'll begin by creating an Azure Red Hat OpenShift cluster using the `azure-native.redhatopenshift.OpenShiftCluster` resource.

2. **Install the Helm Chart for Prometheus Alertmanager**: After the cluster is ready, we will use the `kubernetes.helm.v3.Chart` resource to deploy the Prometheus Alertmanager Helm chart onto the OpenShift cluster.

Here is an outline of the Pulumi TypeScript program that accomplishes this:

- Import necessary packages.
- Configure the OpenShift cluster.
- Deploy the Alertmanager Helm chart on the OpenShift cluster.

Let's start writing our Pulumi program:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";
import * as openshift from "@pulumi/openshift";

// Configuring an Azure Red Hat OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    // Replace these with real values or Pulumi configuration references
    resourceGroupName: "myResourceGroup",
    location: "eastus",
    clusterProfile: {
        domain: "example.com", // Specify the domain for your cluster
        version: "4.3.0", // Specify the OpenShift version
        resourceGroupId: "/subscriptions/[subscription-id]/resourceGroups/[rg-name]", // Specify your own Azure resource group ID
        pullSecret: "", // Your pull secret to authenticate with Red Hat
    },
    networkProfile: {
        podCidr: "10.128.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
    masterProfile: {
        subnetId: "/subscriptions/[subscription-id]/resourceGroups/[rg-name]/providers/Microsoft.Network/virtualNetworks/[vnet-name]/subnets/[subnet-name]" // Replace with the subnet ID for your master nodes
    },
    workerProfiles: [
        {
            name: "worker",
            count: 3,
            vmSize: "Standard_D4s_v3", // Choose the VM size for workers
            diskSizeGB: 128,
            subnetId: "/subscriptions/[subscription-id]/resourceGroups/[rg-name]/providers/Microsoft.Network/virtualNetworks/[vnet-name]/subnets/[subnet-name]", // Replace with the subnet ID for your worker nodes
        },
    ],
});

// Configuring the Kubernetes provider to connect to the OpenShift cluster
const k8sProvider = new k8s.Provider("openshiftK8s", {
    kubeconfig: openshiftCluster.kubeconfig, // Kubeconfig output provided by the OpenShift cluster resource
});

// Deploy Prometheus Alertmanager using Helm chart
const prometheusAlertmanagerChart = new k8s.helm.v3.Chart("prometheusAlertmanager", {
    chart: "alertmanager",
    version: "0.22.2", // Specify the version of Alertmanager chart you wish to deploy
    fetchOpts: {
        repo: "https://prometheus-community.github.io/helm-charts",
    },
}, { provider: k8sProvider });

// Export the OpenShift cluster's kubeconfig
export const kubeconfig = openshiftCluster.kubeconfig;
```

Here's a breakdown of what each part of the code does:

- We're importing the `@pulumi/pulumi` package which is the core of the Pulumi SDK. It allows creating, querying, and managing resources.
- We're importing `@pulumi/azure-native` to work with Azure resources natively.
- We're using `@pulumi/kubernetes` to interact with Kubernetes resources, and `@pulumi/kubernetes/helm/v3` to manage Helm charts.
- We create an Azure Red Hat OpenShift cluster using `azure_native.redhatopenshift.OpenShiftCluster`, specifying details such as resource group, location, cluster profile, network profile, and node profiles.
- We then configure the Pulumi Kubernetes provider to connect to the created OpenShift cluster using the kubeconfig provided by the aforementioned Azure resource.
- With the Kubernetes provider configured, we use `k8s.helm.v3.Chart` to deploy the Prometheus Alertmanager, specifying the chart name, version, and repository.

Remember to replace placeholder values (wrapped in `[...]`) with actual information related to your Azure account and OpenShift configuration. Lastly, the kubeconfig required to interact with your new OpenShift cluster is exported, allowing you to manage your cluster with `kubectl` or other Kubernetes tools.

When you run this Pulumi program using `pulumi up`, it will provision the resources described above within your Azure account. After confirmation, Pulumi performs the required API calls to Azure to set up the resources, and once the OpenShift cluster is running, it will install the Prometheus Alertmanager Helm chart onto it.