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

Question

Pulumi · Accepted Answer

To deploy the Dapr dashboard using a Helm chart on Azure Kubernetes Service (AKS), you'll need to follow several steps:

1. **Create an AKS cluster**: Use the `azure-native` provider to build an AKS cluster. This step involves declaring a cluster resource and specifying the necessary properties such as the location, resource group, and cluster size.

2. **Install the Dapr dashboard**: After the cluster is up and running, you can proceed to deploy the Dapr dashboard. Pulumi enables the use of Helm charts through the `kubernetes` provider. You will configure the Helm chart settings, which includes the chart version and any values you wish to override.

Below is a Pulumi program in TypeScript that carries out these steps:

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("resourceGroup", {
    location: "East US", // You can choose a different location
});

// Create an AKS cluster for our Kubernetes services
const cluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    defaultNodePool: {
        name: "default",
        nodeCount: 2,
        vmSize: "Standard_D2_v2", // You can choose a different VM size
    },
    dnsPrefix: `${pulumi.getProject()}-${pulumi.getStack()}`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3Nza...", // Replace with your actual SSH public key
        },
    },
    servicePrincipal: {
        clientId: "your-service-principal-client-id",
        clientSecret: "your-service-principal-client-secret",
    },
});

// Export the Kubeconfig
export const kubeconfig = cluster.kubeConfigRaw;

// Initialize a Pulumi Kubernetes provider using the AKS cluster's Kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy the Dapr dashboard Helm chart onto the AKS cluster
const daprDashboardChart = new k8s.helm.v3.Chart("dapr-dashboard", {
    chart: "dapr-dashboard",
    version: "0.6.0", // Replace with the version you want to deploy
    fetchOpts: {
        repo: "https://dapr.github.io/helm-charts/",
    },
}, { provider: k8sProvider });

// Export the dashboard service endpoint
export const dashboardEndpoint = daprDashboardChart.getResourceProperty("v1/Service", "dapr-dashboard-dapr-dashboard", "status");
```

Here's what's happening in the Pulumi program above:

- First, we create an Azure resource group to hold our cluster resources. Replace `"East US"` with the desired Azure region.

- Next, we declare an AKS cluster, specifying the number and size of nodes, the Linux user profile, and service principal credentials. Update the SSH key and service principal details using your own.

- We export the `kubeconfig` of the cluster so that it can be used to interact with the cluster via `kubectl`.

- A Pulumi Kubernetes provider is initialized using the `kubeconfig` of the AKS cluster. This provider is then used to manage resources in the AKS cluster.

- We deploy the Dapr dashboard Helm chart by specifying its name, version, and repository URL. The repository URL should point to where Dapr Helm charts are hosted, in this case, Dapr's official Helm chart repository.

- Finally, we export the Dapr dashboard service endpoint, which you can use to connect to the deployed dashboard once it's up and running.

Remember to replace the placeholders (`your-service-principal-client-id`, `your-service-principal-client-secret`, and SSH public key) with your actual service principal credentials and SSH public key.

To run this Pulumi program, you'll first ensure that you have Pulumi installed and configured for TypeScript along with the `@pulumi/azure`, `@pulumi/azuread`, and `@pulumi/kubernetes` npm packages. Save the code to a `index.ts` file and deploy with `pulumi up`.

Please note, Azure may have changed since my knowledge cut-off in early 2023, ensure you are using the correct service principal and other deployment specifics updated to your current date requirements.