Deploy the http-echo helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `http-echo` Helm chart on an Azure Managed OpenShift service using Pulumi, we will go through the following steps:

1. Set up the Azure Managed OpenShift cluster using the `azure-native.containerservice.OpenShiftManagedCluster` resource.
2. Deploy the `http-echo` Helm chart on the OpenShift cluster using the `kubernetes.helm.v3.Chart` resource.

First, let's understand the resources we are using:

- `azure-native.containerservice.OpenShiftManagedCluster`: This is an Azure-native Pulumi resource that creates an OpenShift Managed Cluster in Azure. This resource allows us to configure various aspects of the OpenShift cluster, such as node count, VM size, and network settings.

- `kubernetes.helm.v3.Chart`: This is a Pulumi resource from the Kubernetes provider that allows us to deploy Helm charts on a Kubernetes cluster. In this case, we will use it to deploy the `http-echo` chart onto our OpenShift cluster.

Below is a TypeScript program that demonstrates how to perform both steps:

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

// Step 1: Create the Azure Managed OpenShift cluster
const openshiftCluster = new azure.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
    // Replace these with appropriate values
    resourceName: "myOpenShiftCluster",
    resourceGroupName: "myResourceGroup",
    location: "East US",
    openShiftVersion: "4.3", // Specify your OpenShift version
    networkProfile: {
        vnetCidr: "10.0.0.0/8",
    },
    masterPoolProfile: {
        count: 3,
        vmSize: "Standard_DS3_v2",
    },
    agentPoolProfiles: [{
        name: "agentpool",
        count: 3,
        vmSize: "Standard_DS3_v2",
        role: "compute",
    }],
});

// Once the cluster is created, we need to configure the Kubernetes provider to use the cluster credentials
const creds = pulumi.output(azure.containerservice.listOpenShiftManagedClusterUserCredentials({
    resourceName: openshiftCluster.resourceName,
    resourceGroupName: openshiftCluster.resourceGroupName,
}));

const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: creds.kubeConfigRaw,
});

// Step 2: Deploy the Helm chart
const httpEchoChart = new k8s.helm.v3.Chart("httpEcho", {
    chart: "http-echo",
    version: "0.2.3", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://helm-repo-url.com/", // Specify the repository URL where the chart is hosted
    },
}, { provider: k8sProvider });

// Export the OpenShift cluster's name and the service endpoint of http-echo
export const openShiftClusterName = openshiftCluster.resourceName;
export const httpEchoServiceEndpoint = httpEchoChart.getResource("v1/Service", "http-echo").status.apply(status => status.loadBalancer.ingress[0].ip);
```

Understanding the above code:
- We begin by importing the required modules from the Pulumi SDK.
- We define a new OpenShift managed cluster with certain specifications like location, version, network profile, and agent pool profiles. You would need to replace placeholder values with ones that match your requirements.
- After creating the OpenShift cluster, we retrieve its credentials to set up the Kubernetes provider that Pulumi will use to interact with our cluster.
- Once we have our Kubernetes provider configured, we create a new instance of the `http-echo` Helm chart using the Helm v3 package. We must specify `repo`, which is the repository URL where our Helm chart is located.
- Finally, we export the OpenShift cluster's name and the service endpoint for the deployed `http-echo` service, which can be used to interact with the application.

Remember to replace placeholder values with real values depending on your use case (e.g., resource names, resource group, OpenShift version, VM sizes, Helm chart version, and repository URL).

This program will provision an OpenShift managed cluster and deploy the `http-echo` Helm Chart to it using Azure and Kubernetes resources provided by Pulumi.