Deploy the mockserver helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the MockServer Helm chart on Azure Kubernetes Service (AKS), you'll need to perform several steps:

1. Create an AKS cluster using Pulumi's `azure-native` provider.
2. Install the Helm chart into the AKS cluster.

Here's a step-by-step guide detailing how to accomplish this with Pulumi and TypeScript.

### Step 1: Creating an AKS Cluster

You'll start by setting up an Azure AKS cluster. The `azure-native` provider offers a resource named `ManagedCluster`, which is used to create and manage an AKS cluster in Azure.

### Step 2: Installing the Helm Chart

After your AKS cluster is provisioned, you'll need to install the MockServer Helm chart. Pulumi's `kubernetes` provider has the `helm.v3.Chart` resource, which enables you to deploy Helm charts.

Now, here's the TypeScript program that will create the AKS cluster and deploy the MockServer Helm chart:

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

// Create an AKS cluster.
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

const cluster = new azure.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "mockserverdns",
    enableRBAC: true,
    kubernetesVersion: "1.19.11",
});

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

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

// Deploy the MockServer Helm chart using the Helm Chart resource.
const mockServerChart = new k8s.helm.v3.Chart("mockserver", {
    chart: "mockserver",
    version: "5.11.2", // specify the version of the helm chart you want to deploy
    fetchOpts: {
        repo: "https://helm.mock-server.com", // MockServer Helm chart repository
    },
}, { provider: k8sProvider });

// Export the front-end IP address of the service to access the MockServer
export const frontEndIp = mockServerChart.getResourceProperty("v1/Service", "mockserver-mockserver", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation

Here's the breakdown of the program:

- **Resource Group**: This creates a new resource group to contain our AKS cluster.
- **AKS Cluster**: We create an AKS cluster with one system node in the `agentPoolProfiles`.
    - `dnsPrefix` is required to access the cluster.
    - `enableRBAC` is set to `true` for role-based access control.
    - `kubernetesVersion` specifies the version of Kubernetes to use.
- **Kubeconfig**: We export the generated kubeconfig, which will be used to interact with the AKS cluster through Kubernetes commands or Kubernetes client libraries.
- **Kubernetes Provider**: This initializes a Pulumi Kubernetes provider with the kubeconfig we obtained from the AKS cluster.
- **MockServer Helm Chart**: We deploy MockServer using its Helm chart from the specified repository, version, and using the provided Kubernetes instance.
- **Front-end IP**: We export the IP address of the load balancer created by the Helm chart, which is what users can access to interact with the MockServer instance.

Run this program with `pulumi up`, and Pulumi will perform the deployment of the AKS cluster followed by the installation of the MockServer Helm chart.

Once deployed, you can connect to MockServer using the exported `frontEndIp` from the Pulumi program. This IP address allows you to interact with your mocked services.

Remember that you need Pulumi CLI installed and configured and appropriate Azure credentials set up to run this program successfully.