Deploy the openshift-buildconfig helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy an application on Azure Kubernetes Service (AKS) using a Helm chart, you will need to perform several steps. In this scenario, we will create an AKS cluster and then deploy the `openshift-buildconfig` Helm chart to it.

Below is a step-by-step guide followed by a Pulumi TypeScript program that accomplishes these goals:

1. **Setting up AKS Cluster**: You'll need an AKS cluster to deploy your application on. With Pulumi, we can define the cluster configuration and create it. This step involves setting up the necessary configurations like node size, number of nodes, etc.
   
2. **Helm Chart Deployment**: After setting up the AKS cluster, we'll use the Helm chart to deploy the `openshift-buildconfig`. We will set up a Pulumi `Chart` resource targeting our AKS cluster to manage the deployment.

In the following Pulumi TypeScript program, first, ensure that you have the `@pulumi/azure-native` and `@pulumi/kubernetes` packages installed. If not, you can install them using `npm` or `yarn`:

```shell
npm install @pulumi/azure-native @pulumi/kubernetes
```

Next, you're going to see a Pulumi program that creates an AKS cluster and then deploys the `openshift-buildconfig` Helm chart.

Please replace the placeholder values in the configuration section with the appropriate values for your environment. You may also need to adjust other configuration settings based on your specific requirements.

Let's begin with the TypeScript program:

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Step 2: Create the AKS cluster
const cluster = new azure.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        nodeLabels: {},
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    enableRBAC: true,
    kubernetesVersion: "1.18.14", // Use the appropriate version
    linuxProfile: {
        adminUsername: "testuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3...yourkeyhere...",
            }],
        },
    },
    nodeResourceGroup: `MC_azure-${pulumi.getStack()}`,
    resourceGroupName: resourceGroup.name,
});

// Step 3: Export the KubeConfig
export const kubeConfig = cluster.kubeConfig;

// Step 4: Setup the Kubernetes Provider to connect to the AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeConfig.apply(JSON.stringify),
});

// Step 5: Deploy the 'openshift-buildconfig' Helm chart on the AKS cluster
const helmChart = new k8s.helm.v3.Chart("openshift-buildconfig", {
    chart: "openshift-buildconfig",
    // This is a placeholder repo URL where your Helm chart is located.
    // Replace it with the actual URL to your Helm chart repository.
    repo: "https://your-helm-chart-repo/",
    version: "1.0.0", // Specify the version of the Helm chart you want to deploy
    // You can specify the namespace and values according to your needs.
    // Below are example configurations.
    namespace: "default",
    values: {
        // Custom values for the Helm chart.
        // Adjust them to match the application's requirements.
    },
}, { provider: k8sProvider });

// Step 6: Export the public IP to access your application if available
// This step depends on the nature of your Helm chart and how it exposes the application
export const frontendIp = helmChart.getResourceProperty("v1/Service", "my-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program outlines the necessary steps and provides a skeleton framework to deploy an AKS cluster and a Helm chart. The `kubeConfig` output is the Kubernetes configuration file necessary to interact with your cluster using `kubectl`. Optionally, a frontend IP address is exported if your application includes a service of type `LoadBalancer`.

The placeholder values (for example, `ssh-rsa AAAAB3...` and `https://your-helm-chart-repo/`) should be replaced with actual values from your environment.

The `helmChart` part of the program uses the Pulumi Kubernetes package's `Chart` resource, which encapsulates Helm chart deployments. It expects information about the chart, including the name, chart version, and any custom values that you might need to provide.

Make sure that you're logged into the Pulumi service and have selected the correct Pulumi stack before running the program. If you have your Pulumi CLI configured, you can deploy the infrastructure and application with:

```shell
pulumi up
```

This command will prompt you to review the plan and then deploy the changes.

Remember, Helm charts often include various Kubernetes resources like deployments, services, ingress objects, etc. You might want to examine the Helm chart for the actual resources created and adjust any resource-specific configurations accordingly.