Deploy the ibmcloud-service helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy an IBM Cloud Service using the Helm chart on Azure Kubernetes Service (AKS), we will need to perform a few steps. This includes setting up an AKS cluster, installing and configuring Helm on our local machine or within a CI/CD pipeline, and deploying the IBM Cloud Service helm chart to the AKS cluster.

In this program, we will focus on creating an AKS cluster using Pulumi's infrastructure as code (IaC) methodology. We will define our desired state in TypeScript, and Pulumi will ensure that the AKS cluster is created according to our specifications. For deploying the Helm chart, normally, you would use tools like Helm CLI, but to keep things within the Pulumi framework, we'll also use Pulumi's Kubernetes provider to deploy a Helm chart directly.

To achieve this, we will use the following Pulumi resources:
- `azure-native:containerservice:KubernetesCluster`: This represents an AKS cluster in Azure. We will configure this with the necessary details such as the node size, the number of nodes, and the Kubernetes version.
- `kubernetes.helm.v3.Chart`: This Pulumi Kubernetes resource represents a Helm chart. We will specify the IBM Cloud Service Helm chart and its settings to install it on our AKS cluster.

Let's start by setting up the AKS cluster.

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

// Define a resource group to contain the AKS cluster
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Create the AKS cluster
const cluster = new azure.containerservice.KubernetesCluster("myAksCluster", {
    resourceName: "myAksCluster",
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        count: 2, // The number of workers
        vmSize: "Standard_B2s", // The size of workers
        modes: ["System"],
        osType: "Linux",
        maxPods: 110,
        type: "VirtualMachineScaleSets",
        name: "agentpool",
    }],
    kubernetesVersion: "1.18.14",
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    // ...Additional settings like service principal, network profile, etc. can be added here.
});

// Get the kubeconfig from the AKS cluster
const kubeconfig = pulumi.all([ cluster.name, resourceGroup.name ]).apply(([clusterName, rgName]) => {
    return azure.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    });
}).apply(creds => Buffer.from(creds.kubeconfigs[0].value, 'base64').toString());

// Create a Kubernetes provider instance using the kubeconfig from the AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy an IBM Cloud Service Helm chart to the AKS cluster
const ibmChart = new k8s.helm.v3.Chart("ibmcloud-service-chart", {
    // Replace with the actual Helm chart information for IBM Cloud Service
    chart: "ibmcloud-service",
    version: "1.2.3", // specify the chart version
    fetchOpts: {
        repo: "https://charts.helm.sh/stable", // Replace with the IBM Cloud Service Helm repository
    },
}, { provider: k8sProvider });

// Export the kubeconfig and the AKS cluster name
export const kubeConfigResult = pulumi.secret(kubeconfig);
export const aksClusterName = cluster.name;
```

In this code:
- We begin by importing our required Pulumi packages.
- We define a resource group to contain our AKS cluster.
- We create the AKS cluster with two worker nodes of `Standard_B2s` size with system mode and Linux OS type.
- We retrieve the kubeconfig which will be used to communicate with our AKS cluster using Kubernetes commands.
- We define the Kubernetes provider using the kubeconfig we retrieved from the AKS cluster. This is what allows Pulumi to communicate with our cluster for deployments.
- We define a Helm chart resource, specifying the location of the IBM Cloud Service Helm chart. Note that you will need to replace `"https://charts.helm.sh/stable"` with the actual location of the IBM Cloud Service Helm repository and `"ibmcloud-service"` with the actual chart name if it's different. The version should also be specified correctly based on the version you wish to deploy.
- Finally, we export the kubeconfig and the cluster name for further use, for example, if you wish to connect to the cluster manually with `kubectl`.

To use this Pulumi program:
1. Replace the placeholder values for the `chart`, `version`, and `repo` fields under `ibmChart` with actual information pertaining to the IBM Cloud Service Helm chart.
2. Ensure your Pulumi CLI is logged in and configured with the correct Azure credentials.
3. Run `pulumi up` in the directory of this program file to create the AKS cluster and deploy the Helm chart.

Keep in mind this example assumes you have Azure credentials configured on your system where Pulumi CLI can access them, and you've installed the required Pulumi and provider packages for your project. Make sure to adjust the resource names and properties as necessary for your context.