Deploy the kubecost helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Kubecost Helm chart on an Azure Managed OpenShift service, you'll need to accomplish a few things:

1. Create an Azure Managed OpenShift cluster.
2. Install the Helm Chart for Kubecost on the OpenShift cluster.

The following is a step-by-step guide on how to achieve both steps using Pulumi with TypeScript.

### Step 1: Create an Azure Managed OpenShift Cluster

Before deploying the Helm chart, you need an OpenShift cluster. The `azure-native.containerservice.OpenShiftManagedCluster` resource is used to create a managed OpenShift cluster on Azure. You'll provide some required properties like `resourceGroupName`, `location`, and the details for the `agentPoolProfiles`, which define the virtual machines where your OpenShift cluster will run.

To begin with, make sure to install the necessary npm packages:

```bash
npm install @pulumi/azure-native
npm install @pulumi/kubernetes
```

And now, here is the TypeScript code that sets up an Azure Managed OpenShift Cluster using Pulumi:

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

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("my-resource-group", {
    location: "East US", // Replace with your desired location
});

// Define the OpenShiftManagedCluster resource
const openshiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("my-openshift-cluster", {
    // Ensure the location matches the Resource Group location
    location: resourceGroup.location,
    resourceName: "myopenshiftcluster",
    resourceGroupName: resourceGroup.name,
    openShiftVersion: "v4.3", // Use a valid OpenShift version
    networkProfile: {
        vnetCidr: "10.0.0.0/8",
    },
    masterPoolProfile: {
        count: 3,
        vmSize: "Standard_D4s_v3",
    },
    agentPoolProfiles: [{
        name: "agentpool",
        count: 3,
        vmSize: "Standard_D4s_v3",
        role: "compute",
    }],
    // Define other required properties based on the OpenShift cluster that you want to deploy
    // This is a simplified configuration and you'll need to input correct values based on your infrastructure needs
}, { dependsOn: resourceGroup });

// Export the OpenShift cluster's name and ID
export const openshiftClusterName = openshiftCluster.name;
export const openshiftClusterId = openshiftCluster.id;
```

### Step 2: Install the Helm Chart for Kubecost on the OpenShift Cluster

Once you have the OpenShift cluster deployed, you can use the Pulumi Kubernetes provider to deploy Helm charts to your cluster.

Below is the continuation of the TypeScript program which deploys Kubecost using its Helm chart. For this step, you'll need to have access to your OpenShift cluster's kubeconfig, which can be obtained from the Azure portal after the cluster finishes creating.

```typescript
// Create a Kubernetes provider instance that uses the kubeconfig from the newly created OpenShift cluster
const k8sProvider = new k8s.Provider("openshift-k8s", {
    kubeconfig: openshiftCluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the Kubecost Helm chart
const kubecostHelmChart = new k8s.helm.v3.Chart("kubecost", {
    chart: "cost-analyzer",
    version: "1.68.0", // Specify the version of Kubecost that you want to install
    namespace: "kubecost", // Specify the namespace where you want the chart to be installed
    fetchOpts: {
        repo: "https://kubecost.github.io/cost-analyzer/", // Helm repository URL containing the chart
    },
    // Define any custom values you want to pass to the Helm chart
}, { provider: k8sProvider });

// Export the name of the Helm release
export const kubecostHelmRelease = kubecostHelmChart.releaseName;
```

In this Pulumi program, we:
- Installed the Kubecost Helm chart into the `kubecost` namespace on the OpenShift cluster.
- Specified the version and Helm repository for Kubecost.
- Created a new instance of `k8s.Provider` that is tied to the kubeconfig of the OpenShift cluster. This ensures that Pulumi communicates with the right Kubernetes cluster when deploying resources.
- Used the `k8s.helm.v3.Chart` resource to declare the Helm chart we want to deploy. Helm charts are a convenient way to package and deploy applications on Kubernetes.

Make sure to replace placeholders like version numbers or resource names with actual valid values that match your requirements.

Finally, run `pulumi up` to create the resources. After the command completes and you get the outputs, you'll have a fully functional OpenShift cluster with the Kubecost Helm chart running. You can connect to your OpenShift cluster using `oc` or `kubectl` by obtaining the kubeconfig from the outputs of the Pulumi deployment or directly from the Azure portal.