Deploy the kube-janitor helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the `kube-janitor` Helm chart on an Azure Managed OpenShift Service, you'll need to follow a series of steps to set up your OpenShift cluster, configure Kubeconfig, and then use the Helm chart to deploy `kube-janitor`. Below is a Pulumi program in TypeScript that will set up the cluster and deploy the Helm chart.

First, you'll need to create an instance of the Azure Managed OpenShift service using Pulumi's `azure-native.containerservice.OpenShiftManagedCluster` resource. Then, you'll deploy the `kube-janitor` Helm chart to this cluster using the Pulumi Kubernetes provider.

Here's an outline of what we'll do in the Pulumi program:

1. Set up the required Azure Managed OpenShift Service using Pulumi's `azure-native` provider.
2. Deploy the `kube-janitor` Helm chart to the OpenShift cluster using Pulumi's `kubernetes` provider.

### Detailed Explanation

1. **Azure Managed OpenShift Cluster**: The `azure-native.containerservice.OpenShiftManagedCluster` resource sets up an Azure Managed OpenShift Service, which is a Kubernetes platform on Azure that provides a managed OpenShift cluster.

2. **Kube Configuration**: Configure the Kubernetes provider with the generated Kubeconfig from the OpenShift cluster to interact with your Kubernetes resources.

3. **Helm Chart Deployment**: With the `kubernetes.helm.v3.Chart` resource, Pulumi can deploy Helm charts to a Kubernetes cluster. You provide details like the chart name, version, and any custom values you want to apply to the Helm chart, which in this case will be for `kube-janitor`.

Let's now start with the Pulumi program:

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

// Step 1: Provision an Azure Managed OpenShift Cluster
const managedCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenshiftCluster", {
    // Provide required properties here
    // Replace placeholders with actual values
    resourceGroupName: "myResourceGroup",
    location: "East US", // Specify the Azure region
    openShiftVersion: "4.3", // Specify the OpenShift version
    // Specify other necessary parameters according to your requirements
});

// Step 2: Use the output of the OpenShiftManagedCluster to configure the Kubernetes provider.
// The `kubeconfig` should be available as an output from the cluster resource.
const k8sProvider = new k8s.Provider("myk8s", {
    kubeconfig: managedCluster.config.apply(c => c.kubeconfig),
});

// Step 3: Deploy the kube-janitor Helm chart using the Kubernetes Helm Chart resource
const janitorChart = new k8s.helm.v3.Chart("kube-janitor", {
    chart: "kube-janitor",
    // Replace with the repository that hosts your `kube-janitor` chart if it's different
    fetchOpts: {
        repo: "https://your-helm-chart-repository.com/",
    },
    // Specify the namespace where the kube-janitor should be deployed
    namespace: "cleanup",
    // Configure any values for the kube-janitor chart (if required)
    values: {
        // ... insert custom values here
    },
}, { provider: k8sProvider });

// Export the cluster name and endpoint
export const clusterName = managedCluster.name;
export const clusterEndpoint = managedCluster.properties.apply(p => p.fqdn);

```

### Key Points

- Ensure that you replace the placeholders with actual values regarding your OpenShift cluster setup (`resourceGroupName`, `location`, etc.).
- If `kube-janitor` is hosted on a different Helm chart repository, update the `repo` field within `fetchOpts`.
- Customize values for the Helm chart deployment as necessary for your environment.
- The use of `apply` is a way to pull out the necessary details from the provisioned resources when they become available.

This program creates an Azure Managed OpenShift cluster and then deploys the `kube-janitor` Helm chart to the cluster. You will need to have your Azure credentials configured for Pulumi, which typically involves logging in via the Azure CLI and then running `pulumi up` to deploy the stack.