Deploy the k8s-node-image-nginx-1-19 helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on an Azure Managed OpenShift Service using Pulumi, we'll need to perform the following steps:

1. Set up an Azure Managed OpenShift cluster.
2. Deploy the specified Helm chart to the cluster.

Below is a program written in TypeScript that uses Pulumi to:

- Create an Azure Managed OpenShift cluster using the `azure-native.containerservice.OpenShiftManagedCluster` resource.
- Deploy the `k8s-node-image-nginx-1-19` Helm chart to this cluster with the `kubernetes.helm.v3.Chart` resource.

I'll explain each part of the program as we go through it.

First, ensure you have Pulumi installed and set up with the Azure provider. You should also have `kubectl` configured to interact with Kubernetes clusters and the Helm CLI if you need to inspect or manage Helm charts directly.

Here's the program:

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

// Set the desired location for our OpenShift cluster
const location = "East US";

// Create an Azure Resource Group to contain our Managed OpenShift cluster
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    location: location,
});

// Deploy an Azure Managed OpenShift cluster
const cluster = new azure_native.containerservice.OpenShiftManagedCluster("openshiftCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    openShiftVersion: "4.3", // Specify the version of OpenShift
    // Define the network profile, including the address prefixes for the subnet.
    networkProfile: {
        vnetCidr: "10.0.0.0/8",
    },
    // Specify the master and worker profiles (node size, count, etc.)
    masterPoolProfile: {
        name: "master",
        count: 3,
        vmSize: "Standard_D4s_v3",
    },
    agentPoolProfiles: [{
        name: "default",
        role: "Compute",
        count: 3,
        vmSize: "Standard_D4s_v3",
    }],
    // Specify the FQDN for the cluster
    // ...
}, { dependsOn: [resourceGroup] });

// Set up a K8s provider to interact with the OpenShift cluster
const openshiftProvider = new k8s.Provider("openshiftK8s", {
    kubeconfig: cluster.config.kubeconfig, // Use the kubeconfig from the created OpenShift cluster
});

// Deploy the Helm chart for nginx 1.19 using the Kubernetes provider
const nginxHelmRelease = new k8s.helm.v3.Chart("nginx", {
    chart: "k8s-node-image-nginx-1-19",
    repositoryOpts: {
        repo: "http://helm-repository/url/to/your/repo", // Specify the Helm chart repository URL
    },
    // Specify the version of the Helm chart, if needed
    version: "1.19",
    // Define values for the Helm chart in this object
    values: {
        // Values corresponding to the Helm chart's values.yaml
    },
}, { provider: openshiftProvider });

// Export the cluster's kubeconfig and the nginx endpoint
export const kubeconfig = cluster.config.kubeconfig;
export const nginxEndpoint = nginxHelmRelease.status.endpoint;
```

In the code above:

- An Azure resource group is created to organize all resources related to the OpenShift cluster.
- The OpenShift cluster is configured with master and worker node profiles specifying the size and number of nodes.
- A Kubernetes (`k8s`) provider is set up using the kubeconfig from the OpenShift cluster, which allows Pulumi to perform operations on the cluster.
- The `nginx` Helm chart is then deployed to this cluster using the `Chart` resource. The chart's name and repository URL are placeholders that you should replace with the actual details for the `k8s-node-image-nginx-1-19` chart. Please note that the actual Helm chart might be under a different name, and the repository URL must point to where the chart is hosted.

Please replace the placeholder `http://helm-repository/url/to/your/repo` with the actual URL to your Helm chart repository.

After running the Pulumi program, the OpenShift cluster with NGINX deployed will be ready and the kubeconfig necessary to interact with the cluster and the endpoint of the NGINX service will be exported as stack outputs.

Ensure you run `pulumi up` to preview and then perform the deployment. The OpenShift cluster creation can take some time, so please be patient. After the deployment is completed, you can use the kubeconfig file that Pulumi exports to connect to your OpenShift cluster and manage it using `kubectl`.