Deploy the planton-cloud-kube-agent helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `planton-cloud-kube-agent` Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you will first create an AKS cluster, and then deploy the Helm chart to this cluster.

Before deploying the Helm chart, ensure you have the following prerequisites:

1. Pulumi CLI installed: Follow the [installation guide](https://www.pulumi.com/docs/get-started/install/).
2. Azure CLI installed: Install the Azure CLI following [instructions from Microsoft](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli).
3. Logged into Azure via the Azure CLI: Run `az login` and follow the prompts.
4. Configured Pulumi to use your Azure credentials: This is typically handled by Pulumi automatically after logging in via the Azure CLI.

Here is the step-by-step Pulumi TypeScript program:

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "EastUS", // You can choose a different region
});

// Step 2: Create an AKS cluster
const aksCluster = new azure.containerservice.KubernetesCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "akspool",
        nodeCount: 1, // You can specify the number of nodes you want in your cluster
        vmSize: "Standard_DS2_v2", // You can choose a different VM size
    },
    dnsPrefix: `${pulumi.getStack()}-kube`,
    identity: {
        type: "SystemAssigned",
    },
});

// Export the AKS cluster's kubeconfig
export const kubeconfig = aksCluster.kubeConfigRaw;

// Step 3: Create a Kubernetes provider instance using the kubeconfig from the AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Step 4: Deploy the Helm chart using the Kubernetes provider
const helmChart = new k8s.helm.v3.Chart(
    "planton-cloud-kube-agent",
    {
        chart: "planton-cloud-kube-agent",
        // Ensure you have the correct repository URL here, or specify `repo` and `version` if not from stable repository.
        fetchOpts: {
            repo: "https://charts.planton-cloud.com/", // Replace with the Helm chart repository URL
        },
        // Specify any custom values you want to pass to the Helm chart
        values: {
            // Typically you put your configuration options here, such as service account details,
            // resource requests and limits, any environment variables or mounted volumes etc.
        },
    },
    { provider: k8sProvider }
);

// Export the Helm chart deployment status
export const helmStatus = helmChart.status;
```

Let's break down what the above Pulumi program does:

1. First, a new Azure resource group is created that will contain all related resources, including the AKS cluster.
2. Next, an AKS cluster is declared using the `azure.containerservice.KubernetesCluster` resource. This includes configuration like the number of nodes and the type of virtual machine.
3. The `kubeconfig` needed to interact with the AKS cluster is then exported. Note that you can also use this `kubeconfig` with `kubectl` or other Kubernetes tools to manage your cluster.
4. A new instance of the Pulumi Kubernetes provider is created, which uses the `kubeconfig` of the AKS cluster to communicate with it.
5. Lastly, the Helm chart for `planton-cloud-kube-agent` is deployed to the AKS cluster. You may need to set some custom `values` depending on the Helm chart's requirements.

Remember to replace the placeholder values in the program with the actual values you need, especially the repository URL for your Helm chart.

Once you've written the Pulumi program:

- Save the program in a TypeScript file, e.g., `index.ts`.
- Run `pulumi up` in your terminal from the directory containing the Pulumi program.
- Pulumi will preview the changes and ask for confirmation to proceed with the deployment.
- Confirm the prompt to start the deployment process.

After these steps, the `planton-cloud-kube-agent` Helm chart will be deployed to your AKS cluster. You can use `pulumi export` to view the deployment status or check the status in the Azure portal.