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

Question

Pulumi · Accepted Answer

In this guide, you'll learn how to deploy a .NET application using a Helm chart on Azure Kubernetes Service (AKS) with Pulumi's infrastructure as code framework. To deploy the application, you need to do the following:

Set up an AKS Cluster: This is the environment where your application will run. AKS manages your hosted Kubernetes environment, making it easier to deploy and manage containerized applications.
Install Helm on your local machine: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications.
Create a Helm Chart for your .NET Application: The Helm chart contains all the necessary components (such as deployments, services, ingress rules, etc.) needed to run your .NET application on Kubernetes.
Deploy the Helm Chart to AKS: Using Pulumi, we'll write a program that deploys the Helm chart to the AKS cluster you set up.

Setting up the AKS Cluster

Firstly, you would need to create an AKS cluster. Below is a Pulumi program written in TypeScript that defines an AKS cluster using the azure-native provider. It describes two primary resources:

ResourceGroup: A container that holds related resources for an Azure solution.
ManagedCluster: Represents the AKS cluster.

Creating the Helm Chart

Once the AKS cluster is set up, you need a Helm chart that defines the .NET application. Helm charts are usually created manually and stored in a repository or packaged and pushed to a Helm chart registry.

Deploying the Helm Chart with Pulumi

Finally, you will deploy the Helm chart to the AKS cluster. This will be achieved by referring to the Helm Chart's repository location and then using kubernetes.helm.v3.Chart to deploy it.

Here is the Pulumi program that sets up an AKS cluster and deploys a .NET application using a Helm chart:

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

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup");

// Create an AKS cluster
const cluster = new azure_native.containerservice.ManagedCluster("myCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "mykube",
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "testuser",
        ssh: {
            publicKeys: [{
                keyData: "<your-ssh-rsa-public-key>",
            }],
        },
    },
    servicePrincipalProfile: {
        clientId: "<your-service-principal-client-id>",
        secret: "<your-service-principal-client-secret>",
    },
});

// Expose the kubeconfig for the newly created AKS cluster.
export const kubeconfig = cluster.kubeConfig;

// Create a Kubernetes provider instance using the kubeconfig.
const provider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfig,
});

// Deploy the dotnet Helm chart using the Kubernetes provider.
const dotnetChart = new k8s.helm.v3.Chart("dotnetChart", {
    chart: "dotnet",
    version: "0.1.0",
    fetchOpts: {
        repo: "http://<your-helm-chart-repository>",
    },
}, { provider });

// Export the public IP to access the application
export const frontendIp = dotnetChart.getResourceProperty("v1/Service", "dotnet", "status").apply(s => s.loadBalancer.ingress[0].ip);

Replace the placeholders <your-ssh-rsa-public-key>, <your-service-principal-client-id>, and <your-service-principal-client-secret> with the actual values that correspond to your Azure account and configurations.

The .apply function call on dotnetChart.getResourceProperty allows us to handle the output properties of a resource that are not available until the resource is created or updated. Here we're getting the public IP of the LoadBalancer that exposes our .NET application.

To run this program:

Ensure you have Pulumi installed.
Ensure you have the Azure CLI installed, and you are logged in using az login.
Provide the actual values for placeholder tokens in the code.
Run npm install to install the necessary dependencies.
Save the code to a file index.ts.
Run pulumi up to create the infrastructure.

Keep in mind that you will need to have your Helm chart for the .NET application created and stored in a repository where Pulumi can access it. The repo property in the dotnetChart should point to the URL of the Helm chart's repository.

Once you've executed pulumi up, Pulumi will communicate with Azure to create the necessary resources. It will set up the AKS cluster and then deploy the Helm chart that contains your .NET application onto the cluster. After the deployment is successful, it will provide an IP address that you can use to access your application.