Deploy the vapormap helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on an Azure Managed OpenShift Service using Pulumi, you would typically need to perform the following steps:

1. Set up an Azure Managed OpenShift Service where the Helm chart will be deployed. This service provides a platform to manage Kubernetes applications and is optimized for OpenShift, which extends Kubernetes with additional features and a user-friendly approach.
2. Install the Helm chart on the Managed OpenShift Service. Helm charts are packages of pre-configured Kubernetes resources, and deploying them involves creating a Kubernetes `Deployment`, `Service`, and potentially other resources like `Ingress`.

Here’s a program that will:
- Create an Azure Managed OpenShift cluster using the `azure-native.containerservice.OpenShiftManagedCluster` resource.
- Deploy a Helm chart to this cluster using Kubernetes provider and `kubernetes.helm.v3.Chart` resource.

Before running the following program, ensure that you have Azure and Kubernetes configuration set up correctly in your Pulumi stack. This involves logging in to the Azure CLI, setting the appropriate context for kubectl if not using the default, and configuring Pulumi with your desired Azure region and Kubernetes version.

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

// Azure OpenShiftManagedCluster requires a ResourceGroup to be created first.
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup", {
  resourceGroupName: "openshiftResourceGroup",
});

// Set the location to the same one as the resource group for proximity
const location = resourceGroup.location;

// Azure RedHat OpenShift cluster creation
const openshiftCluster = new azure.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
  resourceName: "myOpenShiftCluster",
  resourceGroupName: resourceGroup.name,
  location,
  openShiftVersion: "3.11",
  // Define the network properties, cluster properties, etc.
  // These depend on your specific configuration and requirements.
  // ...

// Define agent pool profile for your cluster
  agentPoolProfiles: [{
    name: "compute", // Typically named "compute", it could vary depending on requirements
    count: 3,        // Number of nodes in the OpenShift cluster
    vmSize: "Standard_DS2_v2", // Example VM size
    roleName: "compute",
    subnetCidr: "10.0.0.0/24",
  }],
  // Define master pool profile
  masterPoolProfile: {
    name: "master",
    count: 3,
    vmSize: "Standard_DS2_v2", // Example VM size for master nodes
    subnetCidr: "10.0.0.0/24",
  },
  networkProfile: {
    vnetCidr: "10.0.0.0/8",
  }
  // ...
});

// Create a Kubernetes provider instance using the kubeconfig of the newly-created OpenShift cluster
const k8sProvider = new k8s.Provider("openshiftK8s", {
  kubeconfig: openshiftCluster.config.kubeconfig,
});

// Deploy the "vapormap" Helm chart into the OpenShift cluster.
const vapormapChart = new k8s.helm.v3.Chart("vapormap", {
  // Assuming "vapormap" is the name of the Helm chart you want to deploy
  // The chart can be from the public Helm repository or your own private repository
  chart: "vapormap",
  // Set the version of the chart, if not set it will install the latest version
  version: "1.0.0",
  // Optionally you can specify the repository if vapormap chart is not in the default repo
  // repo: "http://my-helm-repo/",
  values: { // Your Helm chart values go here
    // serviceType: "LoadBalancer", // This is just an example, this must be configured according to vapormap's requirements
    // replicaCount: 3, // Another example, define based on your needs
  },
}, {provider: k8sProvider}); // Ensure to pass the Kubernetes provider we created for OpenShift

// Export the public IP of the LoadBalancer (if your chart exposes any services of type LoadBalancer)
const vapormapServiceIP = vapormapChart.getResourceProperty("v1/Service", "vapormap", "status").apply(status => status.loadBalancer?.ingress[0].ip);
export const publicIP = vapormapServiceIP;
```

Let's walk through what this program does:

- We start by creating an Azure Resource Group, a logical container in which Azure resources are deployed and managed.
- Then, we define and create an Azure Managed OpenShift cluster. The properties for the cluster define parameters such as version, region, size of the VMs for master and worker nodes, and the network configuration.
- Next, we set up a Kubernetes provider pointing at our new cluster. This lets us interface with the cluster using Pulumi's Kubernetes provider.
- We then declare a Helm Chart resource, specifying the chart name ("vapormap"), version, and any required custom values that are relevant to the chart configuration. The `provider` argument ensures that this Helm chart is deployed to the newly-created OpenShift cluster.
- Finally, we provide an export statement allowing us to retrieve the IP address of the service if the deployed Helm chart includes a service of type LoadBalancer.

Keep in mind that specific configurations such as OpenShift version, VM sizes, subnet CIDRs, and Helm chart values must satisfy the requirements of your deployment and are placeholders in the above example.

After setting up the Pulumi program, deploy the stack using the Pulumi CLI:

```sh
pulumi up
```

This will initiate the provisioning of the resources as defined in your TypeScript program.