Deploy the kafka-kraft-on-k8s helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

Deploying a Helm chart onto an Azure Managed OpenShift Service involves several steps: First, you need to create an Azure OpenShift Managed Cluster, then configure Kubernetes and Helm providers to interact with the cluster, and finally use the Helm chart resource to deploy the Kafka Kraft on Kubernetes.

Below is a Pulumi program in TypeScript that demonstrates these steps:

Step 1: Create an Azure OpenShift Managed Cluster

This step involves provisioning an Azure OpenShift Managed Cluster in your specified resource group and region. To do this, we can use the azure-native.containerservice.OpenShiftManagedCluster resource from the azure-native Pulumi provider.

Step 2: Configure Kubernetes and Helm Providers

Once the cluster is running, we need to configure the Kubernetes and Helm Pulumi providers. This involves obtaining the necessary Kubeconfig information from the OpenShift cluster and using it to configure the providers.

Step 3: Deploy Kafka Kraft Helm Chart

With the providers configured, we can now deploy the kafka-kraft-on-k8s Helm chart onto the cluster. This is achieved using the kubernetes.helm.sh/v3.Chart resource, where we provide the Helm repository and chart name along with any custom values that may be required for the deployment.

Let’s proceed with the detailed Pulumi TypeScript program:

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

// Step 1: Create the Azure Managed OpenShift Cluster
const resourceName = "openshiftCluster"; // choose a name for your OpenShift cluster resource
const resourceGroupName = "myResourceGroup"; // replace with your resource group name
const location = "eastus"; // replace with your Azure region

const openshiftCluster = new azure_native.containerservice.OpenShiftManagedCluster(resourceName, {
    resourceGroupName: resourceGroupName,
    location: location,
    openShiftVersion: "v4.6", // choose the version of OpenShift you want
    // The rest of the configuration for the cluster goes here,
    // including network settings, agent pool configuration, etc.
});

// Step 2: Configure the Kubernetes and Helm Providers
// Obtain the Kubeconfig from the OpenShift cluster once it's up and running
const kubeconfig = openshiftCluster.config; // This outputs the kubeconfig of the created cluster

// Configure the Kubernetes provider using the obtained kubeconfig
const k8sProvider = new k8s.Provider('k8sProvider', {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the Kafka Kraft Helm Chart
const kafkaKraftChart = new k8s.helm.v3.Chart('kafka-kraft-on-k8s', {
    chart: 'kafka-kraft-on-k8s',
    version: '1.0.0', // replace with the version of the chart you need
    fetchOpts: {
        repo: 'http://<helm-repo-url>', // replace with the Helm repository URL hosting the chart
    },
    // Provide any custom values for configuring the chart deployment
    values: {
        // Your custom configuration goes here
    },
}, { provider: k8sProvider });

// Exports
export const clusterName = openshiftCluster.name;
export const clusterEndpoint = openshiftCluster.properties.fqdn; // Cluster endpoint URL
export const helmChartName = kafkaKraftChart.name; // Helm chart deployment name

To understand the program:

Replace the placeholders (like <helm-repo-url>) with actual values for your setup.
The azure-native provider is used to create an Azure OpenShift Cluster in a specified resource group and location. You may need to adjust additional settings such as networking and sizing based on your needs.
The k8s.Provider is instantiated with the kubeconfig obtained from the Azure OpenShift Cluster, allowing Pulumi to communicate with your Kubernetes cluster.
The k8s.helm.v3.Chart resource represents the Helm chart you want to deploy. You will need to specify the name of the chart, its version, and the repository where it is hosted.
Finally, we export some key outputs that you can use to access your OpenShift cluster and check on the deployed Helm chart.

Please ensure that you have the @pulumi/azure-native and @pulumi/kubernetes packages installed for this program to work.

To run the program, execute it using the Pulumi CLI, which will handle the deployment process defined in the code:

pulumi up

Be sure that you have authenticated with Azure and set the correct subscription using the Azure CLI tools before running the above command. Also, review the Pulumi stack's output for the necessary details related to the cluster and deployed Helm chart.