Deploy the ibm-business-automation-insights-dev helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `ibm-business-automation-insights-dev` Helm chart on Azure Kubernetes Service (AKS), you'll need to do several things:

1. Set up an AKS cluster where you'll deploy your applications.
2. Have the Helm CLI installed on your machine to handle Helm charts.
3. Have a Pulumi project set up to define the infrastructure needed to run the AKS cluster.

Assuming you have the prerequisites such as Pulumi CLI installed and your Azure account configured, you will need to create a new Pulumi TypeScript project, add the necessary dependencies, and define the resources.

In this explanation, I'll guide you through creating an AKS cluster using Pulumi and deploying the `ibm-business-automation-insights-dev` Helm chart to it.

### Setting Up the AKS Cluster

First, we use the `azure-native` package to provision an AKS cluster. This package is directly mapped to Azure's APIs, giving us fine-grained access to Azure's resources. We define the cluster with required properties such as node size, number of nodes, and the Kubernetes version.

### Deploying the Helm Chart

With the AKS cluster set up, we can deploy applications. We'll deploy a Helm chart using the Helm Release resource from the Pulumi Kubernetes provider. This provider allows us to interact with the Kubernetes API, so we can deploy Kubernetes applications and manage other Kubernetes resources.

Let's go through the code to make this happen:

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

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

// Create an AD service principal
const adApp = new azuread.Application("myAdApp");
const adSp = new azuread.ServicePrincipal("myAdSp", { applicationId: adApp.applicationId });

// Create a secret for the service principal
const adSpPassword = new azuread.ServicePrincipalPassword("myAdSpPassword", {
    servicePrincipalId: adSp.id,
    value: "YourPasswordHere",
    endDate: "2099-01-01T00:00:00Z",
});

// Create the AKS cluster
const cluster = new azureNative.containerservice.ManagedCluster("myCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        nodeLabels: {},
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: pulumi.getStack(),
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa PUB_KEY_HERE adminuser"
            }],
        },
    },
    servicePrincipalProfile: {
        clientId: adApp.applicationId,
        secret: adSpPassword.value,
    },
});

// Export the kubeconfig
export const kubeConfig = pulumi.
    all([cluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) => {
        return azure.containerservice.getKubeConfig({
            name: clusterName,
            resourceGroupName: rgName
        });
    });

// Step 2: Deploy the Helm chart onto the AKS cluster
// Use the returned kubeconfig to create a Kubernetes provider instance
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeConfig,
});

// Deploy the IBM Business Automation Insights Helm chart
const ibmChart = new k8s.helm.v3.Chart("ibm-bai", {
    chart: "ibm-business-automation-insights-dev",
    // The repository where the chart can be found and any additional chart values.
    fetchOpts: {
        repo: "https://raw.githubusercontent.com/IBM/charts/master/repo/stable/"
    },
    // You would set values according to your specific configuration needs
    // values: {
    //     /* ... */
    // };
}, { provider: k8sProvider });

// Export the Chart's status
export const helmChartStatus = ibmChart.status;
```

In the code above, we start by creating a new Azure Resource Group. Then, an Azure AD application and service principal are created for AKS to interact with other Azure services under an identity. The next step is to create the AKS cluster with its properties such as node count, VM size, and Kubernetes version. After the AKS cluster is provisioned, we retrieve the kubeconfig which allows us to interact with the AKS cluster using Kubernetes commands.

We then create a Pulumi Kubernetes provider using the obtained kubeconfig. This provider is used in the deployment of the Helm chart `ibm-business-automation-insights-dev`. The `fetchOpts` parameter should specify the Helm repository where the chart is located.

Finally, we export the kubeconfig and Helm chart status, to be used for accessing the cluster and checking the deployment status respectively.

This code will result in an AKS cluster ready for use, and with the `ibm-business-automation-insights-dev` Helm chart deployed onto it. Keep in mind that you should replace placeholder values like `YourPasswordHere` and `ssh-rsa PUB_KEY_HERE adminuser` with appropriate values for your environment. Also, the `values` section in the Helm chart should be configured according to the specific needs of your deployment.