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

Question

Pulumi · Accepted Answer

Deploying the `servicemesh-grafana-dashboard` helm chart on AKS can be done by first setting up an AKS cluster, and then using Pulumi's Kubernetes provider to deploy the helm chart to that cluster. To achieve this, you'll need to perform several steps:

1. Provision an AKS cluster on Azure.
2. Configure Pulumi to communicate with the AKS cluster.
3. Deploy the Helm chart onto the AKS cluster.

Below is a Pulumi program written in TypeScript that performs each of these steps. Before running this code, ensure that you have the necessary prerequisites:

- Pulumi CLI installed and configured
- Azure CLI installed and authenticated to your Azure account
- Kubernetes CLI (kubectl) installed

Here is the detailed Pulumi program:

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

// Step 1: Create a new AKS cluster
const resourceGroupName = new azure.core.ResourceGroup("aksResourceGroup", {
    location: "West Europe", // Azure region where the resources will be created
});

const k8sCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    defaultNodePool: {
        name: "default",
        nodeCount: 2, // Set the desired node count for your cluster
        vmSize: "Standard_DS2_v2", // Set the VM size for your nodes
    },
    dnsPrefix: "k8s-aks-pulumi",
    servicePrincipal: {
        clientId: process.env.AZURE_CLIENT_ID, // Set your Azure Client ID
        clientSecret: process.env.AZURE_CLIENT_SECRET, // Set your Azure Client Secret
    },
});

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

// Step 2: Configure Pulumi to use the AKS cluster kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the servicemesh-grafana-dashboard helm chart onto the AKS cluster
const grafanaChart = new k8s.helm.v3.Chart("servicemesh-grafana-dashboard", {
    chart: "servicemesh-grafana-dashboard",
    version: "1.0.0", // Specify the version of the chart you wish to deploy
    fetchOpts: {
        repo: "https://example-repo.com/charts", // Specify the Helm repo URL where the chart is located
    },
}, { provider: k8sProvider });

// Output the public IP address of the Grafana dashboard service after deployment
const grafanaService = grafanaChart.getResource("v1/Service", "servicemesh-grafana-dashboard");
export const grafanaEndpoint = grafanaService.status.apply(status => status.loadBalancer.ingress[0].ip);
```

Here's how this program works:

- **Resource Group**: We create a new Azure resource group to contain our AKS cluster. The location is set to "West Europe", but you should change this to your preferred Azure region.
- **AKS Cluster**: A new AKS cluster is defined with two nodes of a specific VM size. You'll need to replace `process.env.AZURE_CLIENT_ID` and `process.env.AZURE_CLIENT_SECRET` with your actual Azure credentials.
- **Kubeconfig**: This is exported so that Pulumi and local kubectl commands can interact with the AKS cluster.
- **Kubernetes Provider**: This Pulumi provider instance allows you to deploy resources to the AKS cluster using the provided kubeconfig.
- **Helm Chart**: The `servicemesh-grafana-dashboard` helm chart is deployed using Pulumi's Kubernetes provider. You'll need to replace the chart version and repo URL with the values specific to the servicemesh-grafana-dashboard you wish to use.
- **Grafana Service Endpoint**: After deployment, we attempt to fetch and export the public IP of the Grafana service, which you can use in a web browser to access the Grafana dashboard.

To apply and run this Pulumi program, follow these steps:

1. Save the code to a file named `index.ts`.
2. Run `npm init -y` in the same directory to create a `package.json` file.
3. Install the required Pulumi packages with `npm install @pulumi/azure @pulumi/kubernetes`.
4. Create a new Pulumi stack with `pulumi stack init`.
5. Set your Azure credentials as environment variables for Pulumi to use.
6. Run `pulumi up` to provision the resources and deploy the Helm chart to AKS.

This program will initialize a new Pulumi project, install dependencies, and execute the deployment, resulting in an AKS cluster with the `servicemesh-grafana-dashboard` Helm chart deployed.