Deploy the thanos-config helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `thanos-config` Helm chart on Azure Managed OpenShift Service using Pulumi, you would need to perform several high-level steps:

1. Create an instance of Azure Red Hat OpenShift (ARO) service, which provides a managed OpenShift cluster.
2. Configure Pulumi to use the Azure provider, enabling you to interact with Azure services.
3. Obtain access to the OpenShift cluster so that you can install Helm charts.
4. Use Pulumi's Helm support to deploy the `thanos-config` chart to the OpenShift cluster.

Below, I'll outline the code to perform these steps, assuming you have already set up Pulumi and have the necessary Azure credentials configured on your local machine. The `Resource Group` and the `OpenShiftManagedCluster` will be created in Azure, and then the `Helm chart` will be deployed to this cluster.

First, be sure to install the necessary Pulumi packages by running:

```bash
pulumi plugin install resource azure-native 2.11.0
pulumi plugin install resource kubernetes 4.4.0
```

And add the required packages to your `package.json`:

```json
{
    "dependencies": {
        "@pulumi/azure-native": "2.11.0",
        "@pulumi/kubernetes": "4.4.0",
        "@pulumi/pulumi": "^3.0.0"
    }
}
```

Now, here's the Pulumi TypeScript program that sets up an Azure OpenShift Managed Cluster and deploys the `thanos-config` Helm chart:

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

// Step 1: Create a resource group to contain the Azure Red Hat OpenShift cluster
const resourceGroup = new azure_native.resources.ResourceGroup("my-aro-resource-group", {
    location: "East US", // for example, choose the region that fits best
});

// Step 2: Create the Azure Red Hat OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster("my-openshift-cluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    // Additional required properties will be specified here. The properties below are just placeholders and need to be adjusted.
    clusterProfile: {
        domain: "example",
        pullSecret: "<pull secret>", // Your pull secret from Red Hat OpenShift
        version: "4.x",              // Specify the version of OpenShift you want to deploy
    },
    networkProfile: {
        podCidr: "10.128.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
    masterProfile: {
        vmSize: "Standard_D8s_v3",
        subnetId: "", // Specify the subnet where the master nodes should be created
    },
    workerProfiles: [{
        name: "worker",
        vmSize: "Standard_D4s_v3",
        diskSizeGB: 128,
        subnetId: "", // Specify the subnet where the worker nodes should be created
        count: 3, // Number of worker nodes
    }],
});

// Use Pulumi's Config to fetch additional settings such as the Helm chart version, if needed.
// For example: const config = new pulumi.Config();
// const chartVersion = config.require("chartVersion");

// Step 3: Deploy the Thanos Helm Chart to the OpenShift cluster once it's available
// We'll create a provider that targets our newly created cluster.
const k8sProvider = new k8s.Provider("openshift-k8s", {
    kubeconfig: openshiftCluster.kubeadminConfig.rawConfig, // Use the cluster's kubeconfig
    // Note: Ensure that you have permissions and the correct context set to interact with the Managed OpenShift cluster.
});

// Step 4: Define the Helm chart
const thanosConfigChart = new k8s.helm.v3.Chart("thanos-config", {
    chart: "thanos",
    version: "0.3.0", // replace with the desired chart version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami", // assuming the chart is hosted here, adjust if needed
    },
    // You may also specify `values` in case you need to override default chart values.
}, { provider: k8sProvider });

// Export the URL for the Thanos application
export const thanosUrl = thanosConfigChart.getResourceProperty("v1/Service", "thanos-config", "status").apply(status => status.loadBalancer.ingress[0].ip);

```

In this program:

- We create a new resource group in Azure to contain our OpenShift cluster.
- We then define the OpenShift cluster with its configuration. It is important to provide the `pullSecret` from Red Hat OpenShift and specify the correct version (ensure to replace it with your valid pull secret).
- After the cluster is provisioned, we create a Kubernetes provider instance that points to the OpenShift cluster using its `kubeadminConfig`.
- Finally, we define the `thanosConfigChart` Helm chart for deployment. We specify the name of the chart (`thanos`), and optionally a version number and repository URL.
- An export statement is added to retrieve the loadBalancer IP address where Thanos will be accessible, assuming that the `thanos` chart deploys a service of type LoadBalancer.

To run this program, save it to a file, for example `index.ts`, then execute it using `pulumi up`.

Since you are a novice, it is important to mention that every resource creation or modification in Pulumi is code-driven. Iteratively developing your infrastructure (e.g., adding new services or modifying existing ones) involves editing the TypeScript file and running `pulumi up` to apply the changes. Always ensure that your Pulumi configuration is correct and that the specified resources are available in the selected Azure region. Always review the Pulumi preview before proceeding with the actual deployment to prevent unintended changes.