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

Question

Pulumi · Accepted Answer

To deploy the `grafana-storage` Helm chart on Azure Kubernetes Service (AKS), you first need to have an AKS cluster available. We'll use Pulumi to provision an AKS cluster and then deploy the chart to it.

Here's the plan:
1. Define the AKS cluster using Pulumi's `Azure-Native` provider.
2. Once the cluster is up and running, we'll configure Pulumi's Helm provider to deploy the Grafana Helm chart to our new AKS cluster.

Let's start by setting up an AKS cluster. In Pulumi, each cloud resource is represented as a class, and we can define our infrastructure by creating instances of these classes. We'll also make use of the `pulumi` CLI to select the appropriate configuration such as the Azure location and the node size.

Below is the TypeScript code, with comments that explain what each part of the code is doing:

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

// Define the AKS cluster
const cluster = new azure.containerservice.ManagedCluster("my-aks-cluster", {
    resourceGroupName: "my-resource-group", // Ensure this resource group exists in your Azure account
    agentPoolProfiles: [{
        count: 3,
        vmSize: azure.containerservice.VMSizeTypes.Standard_DS2_v2,
        mode: "System",
        name: "agentpool",
    }],
    dnsPrefix: "my-k8s-cluster",
});

// Export the KubeConfig of the cluster to interact with it using kubectl
export const kubeConfig = cluster.kubeConfig;

// Once AKS is deployed, we can now setup the Helm chart deployment

// Using Pulumi's Kubernetes provider to interact with the AKS cluster
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeConfig,
});

// Deploying the Grafana Helm chart into the AKS cluster
const grafanaChart = new k8s.helm.v3.Chart("grafana-storage", {
    chart: "grafana",
    version: "6.1.17", // specify the version you wish to deploy
    fetchOpts: {
        repo: "https://grafana.github.io/helm-charts", // Grafana's Helm chart repository
    },
    // Use values to set configuration specifics for Grafana, as you would in a values.yaml file
    values: {
        persistence: {
            enabled: true,
            size: "10Gi",
            storageClassName: "default",
        },
        adminUser: "admin",
        adminPassword: "admin",
    },
}, { provider });

// Export the Grafana public service endpoint to access the Grafana instance
export const grafanaServiceUrl = grafanaChart
    .getResourceProperty("v1/Service", "grafana-storage-grafana", "status")
    .apply(status => `http://${status.loadBalancer.ingress[0].ip}`);
```

Run this program with Pulumi using standard Pulumi CLI commands (`up`, `preview`, `destroy`, etc.). You should replace "my-resource-group" with the actual resource group you want to use and adjust other settings as needed.

**Explanation of resources used:**
- `azure.containerservice.ManagedCluster`: This is the Pulumi resource that we use to define an AKS cluster in Azure.
- `pulumi.export`: This allows us to export the kubeConfig needed to interact with the AKS cluster outside of Pulumi.
- `k8s.Provider`: A Pulumi Kubernetes provider that allows us to interact with a Kubernetes cluster, using the kubeConfig from the AKS cluster we created.
- `k8s.helm.v3.Chart`: This allows us to deploy a Helm chart into our Kubernetes cluster. We specify the chart name `grafana` and a repository where the chart can be found.

Additionally, we export the endpoint of the Grafana service after it's deployed, which will allow you to access the Grafana dashboard. Remember, you might need to configure additional services or permissions depending on your setup, like setting up an Ingress controller for better managing access to the services running on AKS.