Deploy the grafana-misc-dashboards helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `grafana-misc-dashboards` Helm chart on Azure Kubernetes Service (AKS), we will go through a multi-step process using Pulumi and TypeScript.

### Steps to Achieve the Goal

1. **Provision an AKS Cluster**: Using the `ProvisionedCluster` resource, we will create a new AKS cluster in Azure. This cluster will be the foundation where our applications and services will run.

2. **Deploy the Helm Chart**: Once we have an AKS cluster, we will deploy the `grafana-misc-dashboards` Helm chart to the cluster using the Pulumi Kubernetes provider. This provider allows us to interact with our Kubernetes cluster to apply configurations, run services, and deploy applications.

### Detailed Steps and Pulumi Program:

Let's start writing our Pulumi program to carry out each step.

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

// Step 1: Provision an Azure Kubernetes Service (AKS) Cluster
// We are creating an AKS cluster with default configurations.
// For production workloads, you would want to customize these configurations.

const resourceGroupName = new azure.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "my-aks-rg",
    location: "EastUS", // Choose the appropriate Azure region
});

const aksCluster = new azure.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    agentPoolProfiles: [{
        count: 2,
        maxPods: 110,
        mode: "System",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
        type: "VirtualMachineScaleSets",
    }],
    dnsPrefix: "aks-grafana",
    enableRBAC: true,
    kubernetesVersion: "1.21.2", // AKS Kubernetes version to use
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa YOUR_SSH_PUBLIC_KEY", // Replace with your SSH public key
            }],
        },
    },
});

// Export the AKS cluster name and Kubernetes configuration
export const clusterName = aksCluster.name;
export const kubeconfig = aksCluster.kubeConfigRaw;

// Step 2: Deploy the grafana-misc-dashboards Helm Chart
// This step assumes you have `grafana-misc-dashboards` chart available in a Helm repository
// The helm chart will be applied with default values; You could also provide a custom `values` object to customize it

const myK8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

const grafanaChart = new k8s.helm.v3.Chart("grafana-misc-dashboards", {
    chart: "grafana-misc-dashboards",
    // Provide the correct repository name where the grafana chart is hosted
    // This also assumes you have added the repository to your Helm repos
    // with the command `helm repo add [repo name] [repo url]`
    // You would specify `repo` analogous to repository name.
    version: "1.2.3", // specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "https://example.com/helm-charts", // Replace with the correct Helm repo URL 
    },
}, { provider: myK8sProvider });

// Now, you will need to run `pulumi up` to provision the resources defined above.
// After the deployment, you should have Grafana running in your AKS cluster.

```

In the above program:

- We first create a new resource group for our AKS cluster using `azure.resources.ResourceGroup`.
- Then, we create an AKS cluster (`azure.containerservice.ManagedCluster`) within the resource group we created. We define properties such as the version of Kubernetes, VM size for nodes, and SSH access details.
- We export the AKS cluster name and the raw Kubernetes configuration so it can be used by `pulumi` to manage resources within the cluster.
- We set up the `k8s.Provider` which uses the exported `kubeconfig` to communicate with the AKS cluster.
- We declare a Helm chart resource (`k8s.helm.v3.Chart`) which will deploy the `grafana-misc-dashboards` chart from the specified Helm repository into the AKS cluster. Replace `"https://example.com/helm-charts"` with the actual repository URL where `grafana-misc-dashboards` is hosted.
- The `export` statement is used to expose cluster details that can be used to interact with the cluster outside of Pulumi, such as through `kubectl`.

### What to Do Next

- You would need to install Pulumi CLI and configure it for Azure.
- Replace `YOUR_SSH_PUBLIC_KEY` with the actual SSH public key you'd use to access AKS nodes.
- Configure the Helm chart repository and ensure the `grafana-misc-dashboards` chart is available.
- Run `pulumi up` to deploy your AKS cluster and Grafana application.
- Access Grafana once it's deployed to configure your dashboards.

Keep in mind that Helm and Kubernetes providers require specific access rights to interact with AKS; ensure your Pulumi setup has the right credentials. Enjoy your new Grafana dashboards on AKS!