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

Question

Pulumi · Accepted Answer

In order to deploy the `rabbitmq-helm-chart` on Azure Kubernetes Service (AKS) using Pulumi, you will need to follow these steps:

1. Set up an AKS cluster on Azure.
2. Configure `kubectl` to connect to the AKS cluster.
3. Use the Pulumi package for Kubernetes to deploy the Helm chart for RabbitMQ.

Below is a detailed Pulumi program in TypeScript that performs these tasks:

### Detailed Explanation:

- **Azure Kubernetes Cluster Creation**:
  We start by creating an AKS cluster using the `azure-native.containerservice.ManagedCluster` class. We need to define properties such as the node count, node size, and Kubernetes version.

- **Kubernetes Provider Configuration**:
  After the AKS cluster is provisioned, we need a way to communicate with it. This is done by creating a `kubernetes.Provider` instance in Pulumi, which uses the kubeconfig from the created AKS cluster.

- **Helm Chart Deployment**:
  Finally, we deploy RabbitMQ using the Helm chart available on the Helm repository. We leverage the `kubernetes.helm.v3.Chart` class and specify the necessary values, such as the chart name and version. We can also include custom configurations through the `values` property if needed.

### Pulumi Program:

```typescript
import * as azure from "@pulumi/azure";
import * as k8s from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";
import * as azuread from "@pulumi/azuread";
import * as random from "@pulumi/random";
import * as tls from "@pulumi/tls";

// Step 1: Create an AKS cluster
const resourceGroup = new azure.core.ResourceGroup("resourceGroup", {
    location: "EastUS", // you can change the location as needed
});

// Generate a strong password for the AKS cluster
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
}).result;

// Create an AD service principal for the AKS cluster
const adApp = new azuread.Application("adApp");

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

// Generate an SSH key for the AKS nodes
const sshKey = new tls.PrivateKey("ssh-key", {
    algorithm: "RSA",
    rsaBits: 4096,
});

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

const k8sCluster = new azure.containerservice.KubernetesCluster("k8sCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "default",
        nodeCount: 2,
        vmSize: "Standard_D2_v2",
    },
    dnsPrefix: pulumi.getStack(),
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: sshKey.publicKeyOpenssh,
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
    kubernetesVersion: "1.18.14",
});

// Export the kubeconfig
export const kubeconfig = k8sCluster.kubeConfigRaw;

// Step 2: Configure kubectl to connect to the AKS cluster
const provider = new k8s.Provider("k8sProvider", {
    kubeconfig: k8sCluster.kubeConfigRaw,
});

// Step 3: Deploy the RabbitMQ Helm chart on the AKS cluster
const rabbitmqChart = new k8s.helm.v3.Chart("rabbitmqChart", {
    chart: "rabbitmq",
    version: "8.11.3", // specify the version of the chart
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider });

// Export the required properties of the cluster and helm deployment, such as the RabbitMQ service endpoint
export const rabbitmqEndpoint = rabbitmqChart.getResourceProperty("v1/Service", "rabbitmqChart-rabbitmq", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

### How to run this program:

1. Ensure you have the Pulumi CLI installed and are logged in.
2. Ensure you have the necessary Azure credentials configured in your environment.
3. Save the above code in a file named `index.ts`.
4. Run `pulumi up` to execute the program. This will provision the resources and deploy RabbitMQ.
5. Once deployment is complete, Pulumi will export the `kubeconfig` and `rabbitmqEndpoint`, which you can use to interact with your AKS cluster and RabbitMQ service.

**Note**: The version used in the `rabbitmqChart` (8.11.3) should be replaced with the version you wish to deploy. You can find the available versions in [Bitnami's Helm chart repository](https://charts.bitnami.com/bitnami).

This program creates the necessary Azure resources and deploys RabbitMQ onto the AKS cluster. Essential properties such as the RabbitMQ endpoints are exported at the end, allowing you to interact with the newly created RabbitMQ service.