Deploy the mockserver helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the MockServer helm chart on Azure Managed Openshift Service using Pulumi, we will perform two main tasks:

Create an Azure Managed Openshift Service (ARO) cluster using the azure-native.redhatopenshift.OpenShiftCluster resource.
Deploy the MockServer helm chart to the ARO cluster using the kubernetes.helm.sh/v3.Chart resource.

First, we'll set up the OpenShift Managed Cluster. An ARO cluster is a turn-key solution where Microsoft and Red Hat manage the OpenShift cluster. We'll need to define some mandatory properties such as resourceGroupName, location, and profiles for masterProfile, clusterProfile, consoleProfile, and networkProfile for your cluster configuration.

Once our OpenShift Managed Cluster is provisioned, we'll use the Kubernetes provider to interact with the cluster. We'll need to configure the provider with the appropriate credentials, which usually involves obtaining a Kubernetes configuration file with access credentials.

Finally, we'll define a Helm chart resource to deploy the MockServer application. We'll specify the necessary parameters such as chart, version, and any overrides required for values.

Below you'll find an example program written in TypeScript, which you can use as a starting point. Remember to replace placeholders (<...>) with your actual values.

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

// Configure the location and resource group to deploy the resources
const location = "East US";  // Change to your desired Azure region
const resourceGroupName = "<resource-group-name>";  // Provide your resource group name
const clusterName = "<cluster-name>";  // Provide your cluster name

// Create an Azure Resource Group if it doesn't exist
const resourceGroup = new azure_native.resources.ResourceGroup(resourceGroupName, {
    resourceGroupName: resourceGroupName,
    location: location,
});

// Create an Azure Red Hat OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster(clusterName, {
    resourceName: clusterName,
    resourceGroupName: resourceGroupName,
    location: location,
    clusterProfile: {
        pullSecret: "<pull-secret>", // Replace with your pull secret
        domain: "<domain-name>", // Replace with a valid domain name
        version: "4.7.0", // Replace with the desired OpenShift version
    },
    masterProfile: {
        vmSize: "Standard_D8s_v3", // Replace with the desired VM Size
        // Specify the subnet ID with a preconfigured subnet if necessary
    },
    networkProfile: {
        podCidr: "10.128.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
    // Add other profiles and configurations as necessary
});

// Deploy a Helm chart for MockServer
const mockServerChart = new k8s.helm.v3.Chart("mockserver", {
    chart: "mockserver",
    version: "5.11.2", // Specify the chart version
    fetchOpts: {
        repo: "https://helm.mock-server.com", // MockServer Helm chart repository
    },
    namespace: "default",
}, { provider: k8sProvider });

// Export the OpenShift cluster's API server URL
export const openshiftApiServerUrl = openshiftCluster.apiserverProfile.apply(ap => ap.url);

Here's a brief description of what each part of the program does:

We start by importing the necessary Pulumi packages.
We then specify the location and name for the Azure resource group and the ARO cluster.
We proceed to create the resource group and ARO cluster and configure the relevant profiles, which include the cluster, master, and network profiles.
After the OpenShift cluster is set up, we use the Pulumi Kubernetes provider to interact with it. In this example, we expect that you have configured the k8sProvider with the appropriate kubeconfig for your cluster.
Next, we declare a Helm chart resource for deploying MockServer. We specify the chart name, version, and the repository where the chart can be found.
Finally, we export the API server URL of the OpenShift cluster which might be useful to access the OpenShift web console or for CLI access.

Please make sure you fill in the placeholders with the actual values you intend to use, such as your resource group name, cluster name, domain name, and pull secret, which can be obtained from Red Hat OpenShift or your organization's OpenShift subscription details.

Before running this Pulumi program, ensure you have authenticated with Azure, and have access to create resources within the specified subscription and resource group. Additionally, ensure you have installed the Pulumi CLI and configured it correctly to manage resources in Azure.