Deploy the github-prometheus-exporter helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `github-prometheus-exporter` Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi with TypeScript, you will need to follow these steps:

1. **Create an AKS Cluster**: You need an AKS cluster where you can deploy your Helm chart. You'll use the `ProvisionedCluster` resource from the `azure-native` provider.

2. **Install the Helm Chart**: Once you have the AKS cluster up and running, you will use the `Chart` resource from the `kubernetes` provider to deploy your Helm chart onto the AKS cluster.

Here's a step-by-step guide with code on how to get this set up:

### Step 1: Define AKS Cluster

Firstly, you'll create an AKS cluster. The code below sets up an AKS cluster with default settings. Please ensure you are aware of the costs and manage configurations according to your requirements.

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

// Step 1: Create the AKS cluster
const resourceGroupName = "myResourceGroup";
const resourceName = "myAKSCluster";

// Create an Azure Resource Group
const resourceGroup = new azureNative.resources.ResourceGroup(resourceGroupName);

// Create an AKS cluster
const cluster = new azureNative.containerservice.ManagedCluster(resourceName, {
    // Define the properties for your AKS cluster here.
}, { resourceGroupName: resourceGroup.name });
```

### Step 2: Install Helm Chart on AKS

Assuming the Helm Chart is available on a public Helm repository, the next step is to add the chart to the cluster.

```typescript
// After the AKS cluster is provisioned, we can get the kubeconfig
const creds = pulumi.output(azureNative.containerservice.listManagedClusterUserCredentials({
    resourceName: resourceName,
    resourceGroupName: resourceGroupName,
}));

// Use the kubeconfig to create a k8s provider instance for the cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: creds.apply(c => Buffer.from(c.kubeconfigs[0].value, 'base64').toString()),
});

// Define the Helm chart, this can be from a repository or a local directory.
const chart = new k8s.helm.v3.Chart("github-prometheus-exporter", {
    chart: "github-prometheus-exporter",
    version: "1.0.0", // Specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "http://helm-repo-url.example.com/", // Replace with the URL of the Helm repo
    },
}, { provider: k8sProvider });
```

In the example, replace the Helm repository URL with the actual URL where the `github-prometheus-exporter` Helm chart is located. Adjust the version number (`"1.0.0"`) if needed to reflect the chart version you desire.

### Step 3: Export Required Outputs

After deploying your chart, there might be certain information that you need to export – for instance, service endpoints.

```typescript
// Export the Cluster name and Kubeconfig
export const aksClusterName = cluster.name;
export const kubeconfig = creds.apply(c => Buffer.from(c.kubeconfigs[0].value, 'base64').toString());
```

And that's it! When you run `pulumi up`, this program will first provision an AKS cluster through Azure and then deploy the `github-prometheus-exporter` Helm chart onto that AKS cluster. The `kubeconfig` output will allow you to interact with your Kubernetes cluster using kubectl or any other Kubernetes tooling.

Make sure you have Pulumi CLI installed and configured along with the necessary cloud provider credentials before executing the code. Once you're set up with Pulumi, you can run the `pulumi up` command to create the resources.