Deploy the kubecost helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the Kubecost helm chart on Azure Kubernetes Service (AKS), you would need to follow these steps:

1. **Create an Azure Kubernetes Service (AKS) Cluster**: First, you need to set up an AKS cluster where your applications will run. The AKS cluster provides a managed Kubernetes service that simplifies the deployment and operations of Kubernetes.

2. **Install the Pulumi Kubernetes Provider**: The Kubernetes provider for Pulumi will help us to interact with our Kubernetes cluster to deploy applications and configurations.

3. **Configure Helm and Tiller**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications. Tiller is the server-side component of Helm (note that Helm 3+ no longer requires Tiller).

4. **Deploy Kubecost**: Kubecost provides real-time cost visibility and insights for teams using Kubernetes, helping you to monitor and manage your costs directly within your Kubernetes environment.

The following TypeScript program demonstrates how you could deploy the Kubecost helm chart on an AKS cluster using Pulumi.

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

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("my-resource-group");

// Create an AKS cluster
const cluster = new azure.containerservice.ManagedCluster("my-aks-cluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "myk8s",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...", // enter your public SSH key here
            }],
        },
    },
    nodeResourceGroup: `${pulumi.getStack()}-aks`,
    resourceGroupName: resourceGroup.name,
});

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

// Using our kubeconfig, create a Kubernetes provider instance
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Use the pulumi/kubernetes library to install the kubecost helm chart
const kubecostChart = new k8s.helm.v3.Chart("kubecost", {
    chart: "cost-analyzer",
    version: "1.68.1", // specify the version to ensure repeatable deployments
    fetchOpts: {
        repo: "https://kubecost.github.io/cost-analyzer/",
    },
}, { provider: k8sProvider });

// Export the Kubecost service endpoint
export const kubecostService = kubecostChart.getResource("v1/Service", "kubecost/cost-analyzer");

```

### Explanation

- We first import the required Pulumi packages for Azure and Kubernetes.
- A new resource group is created in Azure to hold our AKS resources.
- We then create an AKS cluster within the newly created resource group, specifying the desired settings like the number of nodes, VM size, and the public SSH key for admin access.
- The kubeconfig needed to interact with the Kubernetes cluster is then exported. This kubeconfig allows us to use tools like `kubectl` to interact with our Kubernetes cluster.
- We create an instance of the Pulumi Kubernetes provider, passing it the kubeconfig of our AKS cluster. This provider is used to deploy Kubernetes resources to our AKS cluster.
- Finally, we use Pulumi's Kubernetes library to deploy the kubecost helm chart to our AKS cluster. We fetch the helm chart from the kubecost repository and create a Helm Chart resource. The version is explicitly specified to ensure that our deployment remains consistent across repeated deployments.
- Then we export the service endpoint of kubecost, which can be used to access the Kubecost dashboard.

You would use `pulumi up` to create the cluster and deploy Kubecost. The `kubeconfig` output can be used to configure `kubectl` or other Kubernetes management tools. The `kubecostService` output will give you the details to access the Kubecost dashboard once deployed.