Deploy the turbonomic-importer helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `turbonomic-importer` Helm chart on Azure Managed OpenShift Service using Pulumi, we'll proceed with the following steps:

1. Set up the necessary Azure infrastructure for an OpenShift Managed Cluster.
2. Deploy the Helm chart to the OpenShift cluster.

We'll use two main resources from the Pulumi Azure Native provider:

- `OpenShiftManagedCluster`: This resource will create and manage an Azure OpenShift Managed Cluster. ([documentation](https://www.pulumi.com/registry/packages/azure-native/api-docs/containerservice/openshiftmanagedcluster/))
- `Chart`: This is a Helm chart resource provided by the Pulumi Kubernetes provider that allows us to deploy Helm charts on a Kubernetes cluster. ([documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/chart/))

First, we'll define the OpenShift Managed Cluster with the necessary configurations such as the location, the OpenShift version, resource group, and the specifications for the agent pool that will host the nodes for the OpenShift cluster.

After we establish the cluster, we'll deploy the `turbonomic-importer` Helm chart using the `Chart` resource. We'll need to specify the chart name, version, any custom values if required, and most importantly, the OpenShift cluster where the Helm chart will be deployed.

Here's the Pulumi program in TypeScript that achieves this:

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

// Step 1: Create Azure Managed OpenShift Cluster
const openshiftManagedCluster = new azureNative.containerservice.OpenShiftManagedCluster("openshiftCluster", {
    // Provide the required values here, for example:
    resourceGroupName: "myResourceGroup",
    resourceName: "myOpenshiftCluster",
    location: "East US", // choose the appropriate Azure region
    openShiftVersion: "4.3", // specify the OpenShift version
    networkProfile: { 
        vnetCidr: "10.0.0.0/8",
    },
    masterPoolProfile: {
        count: 1, // Number of master nodes, typically 1, 3, or 5
        vmSize: "Standard_D4s_v3", // VM size for master nodes
    },
    agentPoolProfiles: [{
        name: "agentpool",
        role: "compute",
        count: 3,
        vmSize: "Standard_D4s_v3", // VM size for agent nodes
    }],
});

// Use the kubeconfig from the created OpenShift Managed Cluster to interact with the cluster
const kubeconfig = openshiftManagedCluster.config.apply(config => Buffer.from(config, 'base64').toString('ascii'));

// Pulumi Kubernetes provider uses the kubeconfig to interact with the OpenShift cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy the Helm chart to the OpenShift Cluster
const helmChart = new k8s.helm.v3.Chart("turbonomic-importer", {
    // Specify the actual Helm chart name and repository details
    chart: "turbonomic-importer", // This should be the name of the Helm chart you wish to deploy
    version: "1.0.0", // Specify the chart version, if known
    // If a specific repository is required, uncomment and fill in the following lines
    /* fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the correct Helm chart repository URL
    }, */
}, { provider: k8sProvider });

// Export the OpenShift Managed Cluster's URL.
export const clusterUrl = openshiftManagedCluster.clusterPublicHostname;
```

In this program:

- We instantiate an `OpenShiftManagedCluster`, specifying a resource group name and other details like location and the sizes of the master and agent nodes.
- We take the kubeconfig output from the created OpenShift Managed Cluster, which allows us to interact with it programmatically.
- We then feed this kubeconfig into a new Pulumi Kubernetes provider, which serves as the interface to our Kubernetes/OpenShift resources.
- Next, we define a `Chart` resource to deploy the `turbonomic-importer` Helm chart to the cluster. Make sure to specify the correct repository if the chart is not in the default Helm repository.
- Finally, we export the cluster's public hostname, which can be used to access the OpenShift Managed Cluster.

Make sure to replace placeholder strings like `"myResourceGroup"` and `"myOpenshiftCluster"` with your specific values, and adjust configurations such as VM sizes, count, and region as per your requirements. Also, the Helm chart name, version, and repository details should be updated to point to the `turbonomic-importer` chart you want to deploy.

To run this Pulumi program, save it to a `index.ts` file, and then execute it with the Pulumi CLI, which will handle the resource provisioning on Azure and the Helm chart deployment. Remember to log in to your Azure account and set up your Pulumi stack before executing the code.