Deploy the fastapi-app helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `fastapi-app` Helm chart on Azure Kubernetes Service (AKS), you will first need to create an AKS cluster, and then use the Helm Chart resource from the Kubernetes Pulumi provider to deploy your application.

Below, I have written a Pulumi program in TypeScript to accomplish this. The program uses the `azure-native` package for provisioning the AKS cluster and the `kubernetes` package to deploy the Helm chart.

I will explain the code step by step:

1. **Setup of Azure Kubernetes Service Cluster**: We will define an AKS cluster with the necessary properties, such as node size, count, and location.

2. **Configure Kubernetes Provider**: Once the AKS cluster is available, we connect to it using the Kubernetes provider. This requires fetching the kubeconfig from the AKS cluster.

3. **Helm Chart Deployment**: With the Kubernetes provider configured, we deploy the `fastapi-app` Helm chart to the AKS cluster.

4. **Export Outputs**: Finally, we export any necessary outputs, such as the AKS cluster name and other details that could be useful after the deployment.

Here is the Pulumi program:

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

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("rg", {
    resourceGroupName: "fastapiResourceGroup",
    location: "WestUS", // You can change the location as needed
});

// Define a list of agent pool profiles for the AKS cluster, usually at least one.
const agentPoolProfiles: azure_native.hybridcontainerservice.AgentPoolProfile[] = [{
    count: 1, // The desired number of agent nodes
    vmSize: "Standard_DS2_v2", // Size of the virtual machines to use
    osType: "Linux", // The operating system type (Linux or Windows)
    agentPoolName: "agentpool" // Agent pool name
}];

// Create an AKS cluster
const cluster = new azure_native.hybridcontainerservice.ProvisionedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    resourceName: "fastapiCluster",
    // Define the properties of the Azure Kubernetes Service cluster
    properties: {
        kubernetesVersion: "1.20.9",
        agentPools: agentPoolProfiles,
        enableRbac: true, // Enabling RBAC for security
        networkProfile: {
            networkPlugin: "kubenet", // Networking plugin to use
        },
    },
    location: resourceGroup.location,
});

// Get the kubeconfig for connecting to the cluster
const creds = pulumi.all([cluster.name, resourceGroup.name]).apply(([clusterName, rgName]) =>
    azure_native.hybridcontainerservice.listManagedClusterUserCredentials({
        resourceName: clusterName,
        resourceGroupName: rgName,
    })
);

// Create a kubernetes provider instance using the kubeconfig
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: creds.apply(c => c.kubeconfigs[0].value),
});

// Deploy the `fastapi-app` Helm chart to the AKS cluster using the Helm Chart resource
const fastapiApp = new kubernetes.helm.v3.Chart("fastapi-app", {
    chart: "fastapi-app",
    version: "1.0.0", // Specify the chart version you want to deploy
    // Optionally, you can specify the Helm repository here if the chart is not local
    fetchOpts: {
        repo: "http://your-helm-chart-repository.com/", // Adjust this to point to the actual Helm repo
    },
}, { provider: k8sProvider });

// Export the cluster name and kubeconfig
export const aksClusterName = cluster.resourceName;
export const aksKubeConfig = creds.apply(c => c.kubeconfigs[0].value);
```

This program should be placed in a `.ts` file in a Pulumi project. To run it, you would execute `pulumi up`.

Important notes:
- Make sure to replace `"http://your-helm-chart-repository.com/"` with the actual URL of the repository that hosts your `fastapi-app` Helm chart.
- The `"1.0.0"` version for the Helm chart is exemplary; replace this with the correct version of your chart.
- The `resourceGroupName` and `location` should be updated based on your actual setup and preferences. 
- The `agentPoolProfiles` value is an example configuration, and it should be adjusted according to the requirements of your workload.

After deployment, you can use the `kubectl` command-line tool with the provided `kubeconfig` to manage your AKS cluster and the deployed applications.