Deploy the tsorage helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the "tsorage" Helm chart on an Azure Managed OpenShift service using Pulumi, you will need to perform the following high-level tasks:

1. Set up a new Azure Managed OpenShift cluster or use an existing one.
2. Install and configure Helm on your local machine to utilize Helm charts.
3. Use Pulumi's Kubernetes provider to deploy the Helm chart to the OpenShift cluster.

Below is a detailed explanation and a Pulumi program written in TypeScript to demonstrate these steps:

### Prerequisites

Before you begin, ensure you have the following prerequisites installed and configured:
- Pulumi CLI
- Azure CLI
- Helm CLI
- kubectl (configured to interact with your OpenShift cluster)

### Setup Azure Managed OpenShift Cluster

For this deployment, we'll create a new Azure Managed OpenShift (`OpenShiftManagedCluster`) cluster. We need some essential properties for the cluster, like `location`, `resourceName`, and `resourceGroupName`. The `agentPoolProfiles` will define the size and count of the VMs that run your container applications.

Here's how to define an OpenShift cluster within Pulumi:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as azure_native from '@pulumi/azure-native';

const resourceGroupName = new azure_native.resources.ResourceGroup("myResourceGroup", {
    // You can specify additional properties here, like location
});

const openShiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
    resourceGroupName: resourceGroupName.name,
    resourceName: "myOpenShiftCluster",
    location: "eastus", // Choose the appropriate Azure region for your cluster
    openShiftVersion: "3.11", // Specify the OpenShift version
    // Define your agent pool profile with VM sizes and counts suitable for your workload
    agentPoolProfiles: [{
        name: "compute", // Name of the agent pool
        role: "compute", // Role of agents in this pool
        count: 3, // Number of agents to host in this pool
        vmSize: "Standard_DS3_v2", // The size of the VMs in the pool
    }],
    // ... other required properties
});
```

### Deploy Helm Chart to OpenShift Cluster

Once you have your OpenShift cluster ready, you can deploy the "tsorage" Helm chart to it. You'll use Pulumi's `Chart` resource from the `@pulumi/kubernetes` package to achieve this:

```typescript
import * as k8s from '@pulumi/kubernetes';

// Deploy the "tsorage" Helm chart
const tsorageChart = new k8s.helm.v3.Chart("tsorage", {
    chart: "tsorage",
    version: "1.0.0", // Specify the chart version. You can adjust it according to the available version.
    fetchOpts: { repo: "http://chart-repository-url/" }, // Replace with the actual Helm chart repository URL
    // Optionally, you can add configurations to 'values' property to customize your Helm deployment.
}, { provider: openShiftProvider });
```

In the above code snippet, replace `"http://chart-repository-url/"` with the actual URL of your Helm repository where the "tsorage" chart is located, and adjust the `version` as needed. The `values` property allows you to provide custom configurations to the Helm chart values. The `provider` specifies that you want to deploy this chart to your OpenShift cluster.

### Complete Pulumi Program

Combining the Azure Managed OpenShift cluster definition and Helm chart deployment, here's the complete Pulumi program:

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

// Create a new resource group for the OpenShift cluster if not using an existing one
const resourceGroupName = new azure_native.resources.ResourceGroup("myResourceGroup", {
    // You can specify additional properties here, like location
});

// Define the managed OpenShift cluster
const openShiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
    resourceGroupName: resourceGroupName.name,
    resourceName: "myOpenShiftCluster",
    location: "eastus",
    openShiftVersion: "3.11",
    agentPoolProfiles: [{
        name: "compute",
        role: "compute",
        count: 3,
        vmSize: "Standard_DS3_v2",
    }],
    // ... other required properties
});

// Assuming you have the pulumi kubernetes provider configured to point to the new openshift cluster
// Deploy the "tsorage" Helm chart
const tsorageChart = new k8s.helm.v3.Chart("tsorage", {
    chart: "tsorage",
    version: "1.0.0",
    fetchOpts: { repo: "http://chart-repository-url/" },
    // Optionally, provide custom configurations
}, { provider: openShiftProvider });

// Export the OpenShift cluster's API server URL
export const openShiftApiServerUrl = openShiftCluster.openShiftApiServerUrl;
```

With this program, you are performing the following operations:
- Creating a resource group in Azure for your OpenShift cluster.
- Defining the OpenShift cluster with the required VM size and count.
- Deploying a Helm chart to the cluster.

After running this Pulumi program, the output will be the OpenShift cluster's API server URL which you can use to access your cluster through `kubectl` or OpenShift web console.

To run this program:
1. Save the code in a file with a `.ts` extension (e.g., `index.ts`).
2. Run `pulumi up` to execute the code and create the resources in Azure.

Please replace placeholder values such as `"http://chart-repository-url/"` with actual values suitable for your deployment scenario.