Deploy the proto-app helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the "proto-app" Helm chart on Azure Managed OpenShift Service using Pulumi, we will perform the following steps:

1. Set up an Azure Managed OpenShift cluster.
2. Deploy a Helm chart on the OpenShift cluster.

We'll begin by creating an Azure Managed OpenShift cluster using the `azure-native.containerservice.OpenShiftManagedCluster` resource. This resource allows us to define an OpenShift cluster managed by Azure, which simplifies the deployment and management of Kubernetes applications.

Once the cluster is created, we will use the `kubernetes.helm.sh/v3.Chart` resource to deploy your Helm chart onto this cluster. This resource is a representation of a Helm chart in Pulumi's Kubernetes provider and allows us to install, update, and manage Helm charts within a Kubernetes cluster.

Here's a TypeScript program that sets up an OpenShift cluster and deploys a Helm chart named "proto-app" to it:

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

// Define the OpenShift Managed Cluster resource.
const openShiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
    // Replace with the appropriate location, resource group name, and other necessary parameters.
    location: "eastus",
    resourceGroupName: "myResourceGroup",
    openShiftVersion: "4.3",
    masterPoolProfile: {
        name: "master", // Sample name for the master pool profile.
        count: 3, 
        vmSize: "Standard_DS3_v2",
    },
    agentPoolProfiles: [{
        name: "agentpool", // Name of the agent pool.
        role: "compute",
        count: 3,
        vmSize: "Standard_DS3_v2",
    }],
});

// Set up a provider to deploy resources to the Azure OpenShift cluster.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: openShiftCluster.kubeconfig.apply(JSON.stringify),
});

// Define the Helm chart resource for deploying "proto-app".
const protoAppChart = new k8s.helm.v3.Chart("proto-app", {
    chart: "proto-app",
    // Specify the repository if it's not a stable Helm chart.
    fetchOpts: { repo: "http://path-to-your-helm-chart-repository.com/" },
    // Optionally specify the version, values, and other configurations as needed.
}, { provider: k8sProvider });

// Export the kubeconfig and the app's endpoint if needed.
export const kubeconfig = openShiftCluster.kubeconfig;
export const protoAppEndpoint = protoAppChart.getResourceProperty("v1/Service", "proto-app", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program:

- We declare an OpenShift Managed Cluster with the necessary profiles for the master and agent nodes. 
  - You'll need to specify the location, resource group name, and other parameters based on your requirements.
  - The `openShiftVersion` refers to the version of OpenShift you want to use.
  - `vmSize` should match your desired VM size for the master and agent nodes.

- We set up a Kubernetes provider pointing at the newly created OpenShift cluster using `kubeconfig` obtained from the OpenShift cluster resource. This provider will be used to interface with the Kubernetes API hosted on the OpenShift cluster.

- We define a Helm chart resource called `proto-app` and specify its configuration. This includes the name of the chart, any values you want to override, and the URL of the repository if it's not in the default Helm chart repository.

- We export `kubeconfig` and `protoAppEndpoint` to be used to interact with and access the deployed application.

Make sure you replace `myResourceGroup`, `http://path-to-your-helm-chart-repository.com/`, and the chart name `proto-app` with the actual values relevant to your deployment.

Lastly, to deploy this configuration, you need Pulumi installed and configured with your Azure credentials. Then, you can run the Pulumi CLI commands to deploy your infrastructure:

```bash
pulumi up
```

This will provision the Azure resources and deploy the Helm chart according to the Pulumi program you've written.