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

Question

Pulumi · Accepted Answer

Deploying a Helm chart to Azure Kubernetes Service (AKS) involves several steps that you're going to walk through. First, you need to create an AKS cluster, and for this, we'll use the azure-native provider which interacts with Azure resources using the native Azure Resource Manager API. After the creation of the AKS cluster, you need to configure kubectl, the Kubernetes command-line tool, to interact with the newly created cluster. Finally, you can deploy your Helm chart to the AKS cluster using the kubernetes provider.

Here's a step-by-step guide along with a Pulumi program written in TypeScript to accomplish this:

Set Up the AKS Cluster:
- To begin with, you will define the AKS cluster using the azure-native.containerservice.KubernetesCluster resource. This will provision the actual Kubernetes cluster in Azure.
Configure Kubeconfig:
- Once the cluster is up and running, you need to obtain the kubeconfig file which will allow you to interact with your cluster via kubectl.
Deploy Helm Chart:
- With kubeconfig set up, you are able to deploy resources to the AKS cluster. You will deploy a Helm chart using the kubernetes.helm.v3.Chart resource from the kubernetes provider.

Let's take a look at the actual Pulumi TypeScript program to accomplish this. Make sure you have Pulumi installed and you're logged into an Azure account where you can create resources.

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

// Create an AKS cluster.
const aksCluster = new azure_native.containerservice.ManagedCluster('aksCluster', {
    // Place your specific details such as location, resource group name, etc.
    // Assuming you already have a resource group created.
    resourceGroupName: 'myResourceGroup',
    location: 'WestUS',
    // Define the AKS cluster properties
    agentPoolProfiles: [{
        count: 2,
        maxPods: 110,
        mode: 'System',
        name: 'agentpool',
        osDiskSizeGB: 30,
        osType: 'Linux',
        vmSize: 'Standard_DS2_v2',
    }],
    dnsPrefix: 'mydns-aks',
    kubernetesVersion: '1.18.14',
    linuxProfile: {
        adminUsername: 'adminuser',
        ssh: {
            publicKeys: [{
                keyData: '<SSH_PUBLIC_KEY>', // Your SSH public key string
            }],
        },
    },
    nodeResourceGroup: 'myNodeResourceGroup',
    enableRBAC: true,
});

// Export the kubeconfig string that can be used to connect to the cluster.
export const kubeconfig = aksCluster.kubeConfigRaw;

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider('k8sProvider', {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Deploy a Helm chart to the AKS cluster we created.
const helmChart = new k8s.helm.v3.Chart('uoapp-helm-chart', {
    chart: 'uoapp',
    // Replace with the repository that contains your chart, if it's not a stable chart
    fetchOpts: {
        repo: 'http://charts.example.com/',
    },
    // Specify your Helm chart values here
    values: {
        // Example values, replace these with your specific configuration
        service: {
            type: 'LoadBalancer',
        }
    },
}, { provider: k8sProvider });

// Optionally, you can export the status of the Helm release
export const helmChartStatus = helmChart.status;

In this program, replace:

"myResourceGroup" with the name of your existing resource group.
"WestUS" with the Azure region you'd like to deploy to.
'<SSH_PUBLIC_KEY>' with your public SSH key (important for security).
'http://charts.example.com/' with the URL of the Helm chart repository containing your uoapp chart.
values map with the actual configuration values that your Helm chart accepts. These values are set depending on your Helm chart's values.yaml file.

Save this TypeScript code into a file named index.ts. To deploy this Pulumi program, run pulumi up from the command line in the same directory where this file is saved.

What the program does is define a new AKS cluster with an associated node pool that will have 2 virtual machine instances. It then exports the kubeconfig which you can use with kubectl to connect to your cluster.

After the AKS cluster creation is complete and pulumi exports the kubeconfig, the Kubernetes provider is configured to use this kubeconfig. Finally, the Helm chart representing your application uoapp is deployed using the provided repository and values.

Remember that for real-world usage, you should manage secrets like SSH keys carefully. Additionally, depending on your Helm chart, you might need to adjust resources, versions, or other configurations specifically for your application's needs.