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

Question

Pulumi · Accepted Answer

Deploying a FastAPI application on Azure Kubernetes Service (AKS) using a Helm chart can be accomplished with Pulumi's Kubernetes and Azure Native providers. Below, I'll break down the steps required to achieve this and then provide a TypeScript program to carry out the deployment.

### Explanation
1. **Create an AKS Cluster**: Begin by provisioning an AKS cluster where our FastAPI application will be hosted.
2. **Deploy Helm Chart**: Once the AKS cluster is up and running, we'll use Pulumi's Kubernetes provider to deploy FastAPI using a Helm chart.

We'll be using the `azure-native` provider to create the AKS cluster because it's the native Azure provider in the Pulumi ecosystem, and the `kubernetes` provider to deploy the Helm chart to the cluster.

### Program and Comments
Here's a TypeScript program that performs the necessary steps:

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("fastapiResourceGroup");

// Step 2: Create an AKS Cluster
// For the sake of brevity and simplicity, we are assuming here that an SSH public key and
// service principal credentials are already available and configured in the environment.
const sshPublicKey = "your-ssh-public-key";
const clientId = "your-service-principal-client-id";
const clientSecret = "your-service-principal-client-secret";

const aksCluster = new azure_native.containerservice.ManagedCluster("fastapiCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "fastapi-k8s",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{ keyData: sshPublicKey }],
        },
    },
    servicePrincipalProfile: {
        clientId: clientId,
        secret: clientSecret,
    },
});

// Step 3: Using the credentials from the AKS cluster to configure the Kubernetes provider
const creds = pulumi.all([resourceGroup.name, aksCluster.name]).apply(([rgName, clusterName]) =>
    azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    }));

const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: creds.apply(creds => Buffer.from(creds.kubeconfigs[0].value, "base64").toString()),
});

// Step 4: Deploy FastAPI using a Helm Chart
const fastapiChart = new k8s.helm.v3.Chart("fastapiChart", {
    chart: "fastapi",
    version: "1.0.0", // replace with the chart version you intend to deploy
    fetchOpts: {
        repo: "http://helm-repo-url/", // replace with the Helm repository URL containing FastAPI chart
    },
}, { provider: k8sProvider });

```

This program will:
- Create a new resource group to host the AKS cluster.
- Provision an AKS cluster with a single system node pool.
- Retrieve the kubeconfig from the created AKS cluster.
- Use the kubeconfig to configure the Pulumi Kubernetes provider.
- Deploy the FastAPI Helm chart to the AKS cluster.

Please ensure you replace placeholders like `your-ssh-public-key`, `your-service-principal-client-id`, `your-service-principal-client-secret`, and Helm chart details with actual values.

Running this Pulumi program will create all the necessary Azure resources and deploy the FastAPI application to AKS.

### To run the Pulumi program:
1. Set up the [Pulumi CLI and authenticate with Azure](https://www.pulumi.com/docs/get-started/azure/).
2. Create a new directory for your Pulumi project and navigate to it.
3. Run `pulumi new typescript` to create a new Pulumi TypeScript project.
4. Replace the auto-generated `index.ts` content with the TypeScript program provided above.
5. Run `pulumi up` to execute the program and provision the resources.

As a reminder, before executing the program, you need to have the credentials for a service principal that has permissions to create resources in your Azure subscription. The SSH public key should also be accessible for setting up cluster access.