Deploy the openvswitch helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Open vSwitch Helm chart on an Azure Managed OpenShift Service using Pulumi, you will need to perform the following steps:

1. **Create an Azure Managed OpenShift Cluster**: For hosting your Kubernetes workloads, an OpenShift cluster must be provisioned. This can be accomplished by using the `azure-native.containerservice.OpenShiftManagedCluster` resource.

2. **Install Helm and Open vSwitch Chart**: After the OpenShift cluster is up and running, you'll need to install Helm on your local machine and use it to deploy the Open vSwitch chart to the cluster.

The following program in TypeScript sets up an Azure Managed OpenShift Cluster and deploys the Open vSwitch Helm chart using Pulumi.

Before running this Pulumi program, ensure that you have installed Pulumi CLI and authenticated with your Azure account. Helm must be installed locally to fetch the chart metadata.

```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("myResourceGroup");

// Define the OpenShift Managed Cluster
const openShiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
  // Use the previously created resource group name for the OpenShift cluster
  resourceGroupName: resourceGroup.name,
  resourceName: "myOpenShiftCluster",
  location: resourceGroup.location,
  openShiftVersion: "4.6", // specify your desired OpenShift version
  // Specify the network profile as required
  networkProfile: {
    vnetCidr: "10.0.0.0/8",
  },
  // Define the Master profile
  masterPoolProfile: {
    count: 3,
    vmSize: "Standard_D4s_v3",
  },
  // Define at least one agent pool which will host workloads
  agentPoolProfiles: [{
    name: "agentpool",
    count: 3,
    vmSize: "Standard_D4s_v3",
    role: "compute",
  }]
}, { dependsOn: resourceGroup });

// Reference the output Kubernetes configuration from the OpenShift cluster
const kubeconfig = openShiftCluster.kubeconfig.apply(c => c);

// Create a Kubernetes Provider instance using the kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
  kubeconfig: kubeconfig,
});

// Define the Helm Chart for Open vSwitch
const ovsChart = new k8s.helm.v3.Chart("openvswitch", {
  chart: "openvswitch",
  version: "1.2.0", // specify the chart version
  fetchOpts: {
    repo: "https://example.com/helm-charts", // specify your Helm chart repository URL
  },
}, { provider: k8sProvider });

export const openShiftClusterName = openShiftCluster.name;
export const openShiftClusterKubeconfig = kubeconfig;

```

Here's what each part of the code does:

- The `azure_native.resources.ResourceGroup` resource creates a new resource group in Azure to contain our resources.

- The `azure_native.containerservice.OpenShiftManagedCluster` resource provisions an OpenShift cluster in Azure. You'll need to specify details like the version, location, network profile, and VM sizes for the master and agent pool.

- The `kubeconfig` variable extracts the kubeconfig from the OpenShiftManagedCluster, which is necessary for the Pulumi Kubernetes provider to manage resources in the cluster.

- The `k8s.Provider` resource sets up the Kubernetes provider with the kubeconfig of the OpenShift cluster.

- The `k8s.helm.v3.Chart` resource deploys the Open vSwitch Helm chart to the OpenShift cluster. You will need to provide the correct chart repository URL and choose the appropriate chart version.

- The `export` statements at the end make it possible to easily retrieve the OpenShift cluster name and kubeconfig using the Pulumi CLI after deployment.

**Please note**:
- This Pulumi program assumes that a Helm chart for Open vSwitch is available at the provided repository URL, which is just an example placeholder. You will need to replace `"https://example.com/helm-charts"` with the actual URL of the Helm repository where the Open vSwitch chart is hosted.
- Adjust the `openShiftVersion` and Helm chart `version` as per the actual available versions.
- Ensure that your Pulumi Azure provider is set up with the correct account credentials before running this program.

To run this Pulumi program, navigate to your project directory in the terminal and run:
```shell
pulumi up
```

This command will start the deployment process where Pulumi will print out the planned changes, ask for confirmation, and proceed to apply the changes to your Azure subscription. After the deployment completes, you can use the kubeconfig to manage your OpenShift cluster and interact with the deployed Open vSwitch using `kubectl`.