Deploy the trainingjobs helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Red Hat OpenShift (ARO), you will go through a few steps. First, you would need to provision an Azure Red Hat OpenShift cluster using Pulumi. After the cluster is up and running, you would deploy the Helm chart to the cluster.

In the following Pulumi program, we will:

Set up an Azure Resource Group.
Create an Azure Red Hat OpenShift cluster within the resource group.
Use the Helm chart to deploy trainingjobs on the ARO cluster.

Note: Before running this program, make sure to have Pulumi CLI and Azure CLI installed and configured for use. The required packages should also be installed with a compatible package manager for Node.js such as npm or Yarn. This also assumes that trainingjobs is a publicly accessible Helm chart or is available in a configured Helm chart repository.

First, install the necessary Pulumi packages by running these commands:

# Install the necessary Pulumi packages
pulumi plugin install resource azure-native 2.11.0
pulumi plugin install resource kubernetes 4.4.0
npm install @pulumi/azure-native @pulumi/kubernetes

Now, you can use this TypeScript code in a Pulumi program.

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('resourceGroup');

// Create an Azure Red Hat OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster('openshiftCluster', {
    resourceGroupName: resourceGroup.name,
    resourceName: 'myAROCluster',
    location: 'East US', // Azure location where the ARO should be created
    openShiftVersion: '4.6', // Specify the version of OpenShift
    clusterProfile: {
        domain: 'example', // Provide the OpenShift domain
        resourceGroupId: resourceGroup.id,
    },
    servicePrincipalProfile: {
        clientId: '<azure-ad-client-id>', // Specify your Azure AD client ID
        clientSecret: '<azure-ad-client-secret>', // Specify your Azure AD client secret
    },
    masterProfile: {
        vmSize: 'Standard_D4s_v3', // Specify VM size for the master nodes
        subnetId: 'subnetId', // Replace with the subnet ID for control plane
    },
    workerProfiles: [{
        name: 'worker', // Name of the worker profile
        vmSize: 'Standard_D4s_v3', // VM size for the worker nodes
        subnetId: 'subnetId', // Replace with the subnet ID for worker nodes
        count: 3, // Number of worker nodes
    }],
    networkProfile: {
        podCidr: '10.42.0.0/16',
        serviceCidr: '10.41.0.0/16',
    },
    apiserverProfile: {
        visibility: 'Public', // API server visibility can be Public or Private
    },
    ingressProfiles: [{
        name: 'default',
        visibility: 'Public', // Ingress visibility can also be Public or Private
    }]
});

// Output the kubeconfig of the ARO cluster
const kubeconfig = openshiftCluster.kubeadminPassword.apply(password => `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${openshiftCluster.clusterProfile.apply(p => p!.pullSecret)}
    server: https://${openshiftCluster.apiserverProfile.apply(p => p!.url)}
  name: aroCluster
contexts:
- context:
    cluster: aroCluster
    user: kubeadmin
  name: aroCluster
current-context: aroCluster
kind: Config
preferences: {}
users:
- name: kubeadmin
  user:
    password: ${password}
    username: kubeadmin`);

// Create a kubernetes provider using the obtained kubeconfig
const k8sProvider = new k8s.Provider('openshiftK8s', {
    kubeconfig: kubeconfig,
});

// Deploy the 'trainingjobs' Helm chart to the ARO cluster using the Kubernetes provider
const trainingJobsChart = new k8s.helm.v3.Chart('trainingJobsChart', {
    chart: 'trainingjobs',  // The name of the chart. Replace with actual chart name if different
    // version: '1.0.0',   // Specify the chart version here if needed
    // fetchOpts: {        // Specify repository options if the chart is not in the default Helm repo
    //   repo: '<your-helm-chart-repository>',
    // },
    values: {
        // Provide any specific values needed by the helm chart
    },
}, { provider: k8sProvider });

// Export the Public IP address of the trainingjobs service
const trainingJobService = trainingJobsChart.getResource('v1/Service', 'trainingjobs');
export const trainingJobPublicIP = trainingJobService.status.apply(status => status.loadBalancer?.ingress[0].ip);

This program starts by importing the required packages and setting up the resource group and OpenShift cluster with azure-native package. The ARO cluster is configured with the necessary profiles for the cluster, authentication, networking, and ingress. Once the cluster is set up, the program uses the kubeadminPassword of the cluster to construct a kubeconfig file format string which is passed to a Kubernetes Provider (from the kubernetes package). Then, a Helm Chart is deployed using this Kubernetes provider. Lastly, it exports the service's public IP address so you can access the deployed trainingjobs application.

To use this Pulumi program, replace placeholders <azure-ad-client-id>, <azure-ad-client-secret>, and subnetId with actual values from your Azure environment. If the Helm chart trainingjobs requires specific settings or if it's hosted in a private Helm repository, you will need to provide the fetchOpts with the appropriate repository details, and pass any configuration values required by the chart.

After the code is set up, you can run the following Pulumi CLI commands to create the resources:

pulumi up # To preview and deploy changes

This command will show you a preview of the resources that will be created in your Azure account and, upon confirmation, will provision them.