Deploy the rabbitmq-producer-randomizer helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `rabbitmq-producer-randomizer` Helm chart on Azure Kubernetes Service (AKS), you'll first need to set up an AKS cluster. Then you'll deploy the Helm chart to the AKS cluster. In Pulumi, we can carry out both these tasks using TypeScript.

Firstly, we create an AKS cluster by using the `ProvisionedCluster` resource from the `azure-native` provider, which allows us to provision a managed Kubernetes cluster on Azure. Then, once we have the cluster set up, we use the `Chart` resource from the `kubernetes` provider to deploy the Helm chart to our AKS cluster.

Here's a complete Pulumi program that does this:

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

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

const adApp = new azuread.Application("app");
const adSp = new azuread.ServicePrincipal("servicePrincipal", {
    applicationId: adApp.applicationId,
});

// Generate random password
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
});

const adSpPassword = new azuread.ServicePrincipalPassword("spPassword", {
    servicePrincipalId: adSp.id,
    value: password.result,
    endDate: "2099-01-01T00:00:00Z",
});

const k8sCluster = new azure.containerservice.KubernetesCluster("k8sCluster", {
    resourceGroupName: resourceGroupName.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "aks",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...", // replace with your SSH public key
            }],
        },
    },
    servicePrincipalProfile: {
        clientId: adApp.applicationId,
        secret: adSpPassword.value,
    },
    kubernetesVersion: "1.18.14",
});

const k8sCreds = pulumi.all([resourceGroupName.name, k8sCluster.name]).apply(([resourceGroupName, clusterName]) =>
    azure.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: resourceGroupName,
        resourceName: clusterName,
    })
);

// Provision a K8s provider instance using the cluster credentials we just obtained
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: k8sCreds.kubeconfigs[0].value.apply((enc) => Buffer.from(enc, "base64").toString()),
});

// Deploy the rabbitmq-producer-randomizer helm chart to the AKS cluster
const rabbitmqChart = new kubernetes.helm.v3.Chart("rabbitmqChart", {
    chart: "rabbitmq-producer-randomizer",
    // Assuming the Helm chart is in a repository that Pulumi can access
    // You would need to replace this URL with the repository URL of the rabbitmq-producer-randomizer chart
    fetchOpts: {
        repo: "https://example.com/helm-charts",
    },
}, { provider: k8sProvider });

// Export the Kubeconfig so that we can access the cluster using kubectl
export const kubeConfig = k8sCreds.kubeconfigs[0].value;
```

### Explanation:

- Import the required Pulumi packages at the top of the program.
- We create a new Azure Resource Group to contain all our resources.
- Generate an Active Directory Application and a Service Principal which AKS uses to interact with other Azure services securely.
- Generate a random password for the Service Principal.
- Define the AKS cluster with one node for simplicity (you can increase the node count).
- Set up the SSH access details under `linuxProfile` with your own public key.
- `kubernetesVersion` is specified, but you should replace it with the version you require.

Note: Ensure that the SSH public key is present at `.ssh/publicKey.pem`. If not, you can replace this filepath with your own SSH public key.

- Fetch the credentials for the AKS cluster to interact with it using Kubernetes commands.
- Set up a Kubernetes provider instance with the obtained credentials, so that Pulumi can communicate with our AKS cluster.
- Deploy the `rabbitmq-producer-randomizer` Helm chart using the Helm Chart resource. Make sure to replace the `repo` URL with the actual repository URL where the Helm chart is stored.
- Export the kubeconfig to be able to access the AKS cluster using the `kubectl` CLI.

With this program, you should be able to deploy your `rabbitmq-producer-randomizer` Helm chart to AKS upon running `pulumi up`.
Remember to replace values where placeholders like SSH public key and Helm repository URL are indicated.