Deploy the ibm-cpd-platform-instance helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy an IBM Cloud Pak for Data (CPD) platform instance using a Helm chart on Azure Red Hat OpenShift (ARO), you need to follow these steps:

1. Set up an Azure Red Hat OpenShift cluster.
2. Install Helm and configure it to work with the OpenShift cluster.
3. Deploy the IBM CPD platform instance using the Helm chart.

We'll be using Pulumi with TypeScript to define and deploy our infrastructure as code. Pulumi is a modern infrastructure as code platform that allows you to define infrastructure in familiar programming languages and deploy it across multiple clouds.

Here's a step-by-step Pulumi program on how to achieve this:

### 1. Define Your Pulumi Project and Stack

Create a new directory for your Pulumi project and inside it, initialize a new Pulumi stack with `pulumi new`.

### 2. Install Prerequisites

You'll need the following Pulumi packages:
- `@pulumi/azure-native` for interacting with Azure resources natively.
- `@pulumi/kubernetes` for deploying Helm charts on Kubernetes.
- `@pulumi/random` for generating any random values if needed, such as a password.

Install them using npm or yarn:

```bash
npm install @pulumi/azure-native @pulumi/kubernetes @pulumi/random
# or
yarn add @pulumi/azure-native @pulumi/kubernetes @pulumi/random
```

### 3. Create the Azure Red Hat OpenShift Cluster

In your Pulumi TypeScript program, define the resources needed to set up an Azure Red Hat OpenShift cluster. You'll need an OpenShiftManagedCluster resource, which represents the OpenShift cluster itself.

### 4. Deploy the IBM CPD Platform Instance Helm Chart

Once the OpenShift cluster is available, you can deploy the IBM CPD Platform Instance Helm Chart using the Pulumi Kubernetes provider. You'll point the Kubernetes provider to the OpenShift cluster, and then use the Helm resource to deploy the chart.

Below is the TypeScript code that demonstrates these steps:

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

// Step 1: Create an Azure Red Hat OpenShift cluster
// Provide the required details like location, resource group, cluster version, etc.
const openshiftCluster = new azureNative.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    // Replace these with your desired values or dynamic inputs.
    location: "eastus", // Azure region
    resourceGroupName: "myResourceGroup",
    clusterProfile: {
        domain: "example",
        version: "4.7", // Specify the OpenShift version you wish to use
    },
    masterProfile: {
        vmSize: "Standard_D16s_v3",
        subnetId: "/subscriptions/subid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/masterSubnet",
    },
    workerProfiles: [{
        name: "worker", // You can define multiple worker profiles if needed
        vmSize: "Standard_D16s_v3",
        subnetId: "/subscriptions/subid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/workerSubnet",
        count: 3,
    }],
    apiserverProfile: {
        visibility: "Public",
    },
    ingressProfiles: [{
        name: "default",
        visibility: "Public",
    }],
    // ... Additional settings if needed
});

// Step 2: Set up the Pulumi Kubernetes provider to point to the newly created OpenShift cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: openshiftCluster.kubeconfig,
});

// Step 3: Deploy the IBM CPD Platform Instance Helm Chart
const ibmCpdPlatformInstance = new k8s.helm.v3.Chart("ibmCpdPlatformInstance", {
    chart: "ibm-cpd-platform-instance",
    fetchOpts: {
        repo: "https://raw.githubusercontent.com/IBM/charts/master/repo/stable/",
    },
    namespace: "cpd",
    // You can provide custom values to the Helm chart using the 'values' property
    values: {
        // Custom values for the installation
    },
}, {
    provider: k8sProvider,
});

// Optionally, you can export the OpenShift cluster's API server URL to access it later
export const openshiftApiUrl = openshiftCluster.apiserverProfile.apply(profile => profile.url);
```

This Pulumi program sets up a new Azure Red Hat OpenShift cluster and deploys the IBM CPD platform instance using the specified Helm chart. Make sure you have the `kubeconfig` to connect to your OpenShift cluster, which Pulumi will use to communicate with your Kubernetes resources.

Remember to replace placeholders (like `myResourceGroup`, `subid`, `myVnet`, and others) with your own specific values or make them dynamic inputs according to your use case.

After you've defined your infrastructure code, run it using the Pulumi CLI:

```bash
pulumi up
```

This will create the resources in Azure and deploy the IBM CPD platform instance to your OpenShift cluster.

Keep in mind that IBM CPD platform and its Helm chart may have specific requirements and configurations, which you'll need to reflect in the `values` section of the `Chart` resource. Please refer to the official IBM documentation for the CPD Helm chart for those details.

Lastly, ensure you're aware of any costs associated with the resources and services provisioned on Azure and that you've set up the necessary permissions for Pulumi to create resources in your Azure account.