Deploy the tt-workflow helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `tt-workflow` Helm chart on Azure Managed OpenShift Service using Pulumi, you'll need to follow a few steps. First, you'll provision an Azure Managed OpenShift Service instance, and then you'll deploy the Helm chart onto that OpenShift cluster.

The resources we'll use from Pulumi are:

- [`azure-native.containerservice.OpenShiftManagedCluster`](https://www.pulumi.com/registry/packages/azure-native/api-docs/containerservice/openshiftmanagedcluster/): Provision an Azure Managed OpenShift Service. This will be the Kubernetes cluster on which our Helm chart will be deployed.
- [`kubernetes.helm.v3.Chart`](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/): Deploy a Helm chart onto our OpenShift Managed Kubernetes cluster.

To achieve this, we will use Pulumi with TypeScript. Below is a Pulumi TypeScript program that shows how to accomplish the deployment.

### Detailed Steps:

1. **Resource Group**: A resource group to organize all the Azure resources.
2. **OpenShift Managed Cluster**: Deploy the Azure Managed OpenShift Service under the resource group.
3. **Helm Chart**: Once the OpenShift cluster is up and running, use Pulumi’s Kubernetes provider to deploy the `tt-workflow` Helm chart to the cluster.

Now, let's put this into a code block:

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

// Set the required variables - adjust these according to your specific needs
const resourceGroupName = `ttWorkflowResourceGroup`;
const clusterName = `ttWorkflowOpenShiftCluster`;
const location = 'East US'; // Azure location where resources will be deployed

// Step 1 - Create a new resource group if it doesn't exist
const resourceGroup = new azure_native.resources.ResourceGroup(resourceGroupName, {
    resourceGroupName: resourceGroupName,
    location: location,
});

// Step 2 - Create an Azure Managed OpenShift Cluster
const openshiftCluster = new azure_native.containerservice.OpenShiftManagedCluster(clusterName, {
    location,
    resourceGroupName: resourceGroup.name,
    openShiftVersion: '4.6', // specify your OpenShift version
    networkProfile: {
        vnetCidr: '10.0.0.0/8',
    },
    masterPoolProfile: {
        count: 3, // Change count based on your redundancy requirements
        vmSize: 'Standard_D4s_v3', // Select an appropriate VM size
    },
    agentPoolProfiles: [{
        name: 'agentpool',
        count: 3, // Change count based on your redundancy requirements
        vmSize: 'Standard_D4s_v3', // Select an appropriate VM size
        role: 'compute',
    }],
});

// Step 3 - Deploy the "tt-workflow" Helm chart into the OpenShift cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: openshiftCluster.config.rawConfig, // this makes the k8s provider target our OpenShift Cluster
});

const ttWorkflowChart = new k8s.helm.v3.Chart("tt-workflow-chart", {
    chart: "tt-workflow",
    version: "1.0.0", // use the specific chart version you need
    // Specify the repo if needed using `repo: "http://..."`,
}, { provider: k8sProvider });

// Export the necessary properties to interact with our deployment
export const kubeConfig = openshiftCluster.config.rawConfig;
export const resourceGroupOutputName = resourceGroup.name;
export const clusterOutputName = openshiftCluster.name;
export const helmChartOutputName = ttWorkflowChart.metadata.name;
```

This program sets up the foundation and the Helm chart on Azure Managed OpenShift Service. It's important to replace the placeholders with the actual values you intend to use, such as the cluster's location, the OpenShift version, and any other configurations specific to your use case.

After deploying this Pulumi program, you can manage the OpenShift cluster and applications through the OpenShift Console or using `kubectl` with the exported kubeconfig.