Deploy the vcluster-onboard helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `vcluster-onboard` Helm chart on an Azure Managed OpenShift cluster using Pulumi, you will need to do the following:

1. Create an Azure Red Hat OpenShift (ARO) cluster.
2. Deploy the `vcluster-onboard` Helm chart to the ARO cluster.

### Step 1: Set up an Azure Red Hat OpenShift Cluster
We'll begin by creating an Azure Red Hat OpenShift cluster using the `azure-native.redhatopenshift.OpenShiftCluster` resource. We'll specify necessary properties like the location, resource group name, and cluster properties, such as the master and worker profiles.

### Step 2: Deploy Helm Chart to the OpenShift Cluster
After we have our ARO cluster set up, we will deploy the Helm chart. To deploy a Helm chart, we'll use the `kubernetes.helm.v3.Chart` resource which allows us to specify the repository and chart details, and configure the deployment as needed.

Here's a Pulumi program that carries out both steps using TypeScript:

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

// Step 1: Creating the Azure Red Hat OpenShift cluster

// Replace these with the actual values
const location = "East US"; // Azure location
const resourceGroupName = "myResourceGroup"; // Resource group name
const clusterName = "myAROCluster"; // Cluster name
const masterProfile = {
    name: "master", // Can be customized
    count: 3, // Number of master nodes
    vmSize: "Standard_D8s_v3", // VM size for the master nodes
};

const workerProfile = {
    name: "worker", // Can be customized
    count: 3, // Number of worker nodes
    vmSize: "Standard_D4s_v3", // VM size for the worker nodes
};

// Create an OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster(clusterName, {
    resourceGroupName: resourceGroupName,
    resourceName: clusterName,
    location: location,
    masterProfile: masterProfile,
    workerProfiles: [
        {
            name: workerProfile.name,
            count: workerProfile.count,
            vmSize: workerProfile.vmSize,
        },
    ],
    // Other necessary cluster configurations go here
});

// Step 2: Deploying the Helm chart to the OpenShift cluster

// It's assumed you've configured K8s provider to connect to your ARO cluster
// You may need to set up a Kubernetes configuration file and use it for the provider
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: openshiftCluster.kubeconfig.apply((config) => config.rawConfig), 
});

// Define the Helm chart for vcluster-onboard
const vclusterOnboardChart = new k8s.helm.v3.Chart("vcluster-onboard", {
    chart: "vcluster-onboard",
    // The repository where the helm chart can be found
    // If it's not a chart from a public repository, you will need to add `repo` attribute with the repository URL
    version: "1.0.0", // Specify the version of the chart
    namespace: "default", // The namespace to deploy the chart into
    // Define values to override the default helm chart values
    values: {
        // You can customize the deployment by providing specific values
    },
}, { provider: k8sProvider });

// Export the kubeconfig and cluster endpoint
export const kubeConfig = openshiftCluster.kubeconfig;
export const clusterEndpoint = openshiftCluster.clusterProfile.apply((profile) => profile.resourceGroupId);

```

In this program, you're:

- Creating an instance of an OpenShift cluster with a master node pool and a worker node pool.
- Setting up the K8s provider with the kubeconfig obtained from the created OpenShift cluster.
- Deploying a Helm chart using the `Chart` resource from the Pulumi Kubernetes provider.

Before you attempt to run this Pulumi program, please ensure that you have the Pulumi CLI installed and configured for use with Azure. You should also be authenticated with Azure either via the Azure CLI or the Pulumi Azure provider.

Remember, you need to replace placeholders (like the resource group name, cluster name, and VM sizes) with the actual values you intend to use.

Run your Pulumi program with `pulumi up`, which will preview and then execute the deployment. Be aware that creating an Azure Red Hat OpenShift cluster can take a significant amount of time.

Once the deployment is successful, you can use the exported kubeconfig to manage your OpenShift cluster and its workloads with `kubectl` or integrate with other CI/CD tools.

Let me know if you need further clarification or assistance with this process!