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

Question

Pulumi · Accepted Answer

To deploy the Quarkus Helm chart on Azure Kubernetes Service (AKS), we will take the following steps:

Create an Azure Kubernetes Service (AKS) Cluster: This is where your applications will be running. AKS simplifies deploying a managed Kubernetes cluster in Azure by offloading the operational overhead to Azure.
Install the Helm Chart for Quarkus: Helm helps you manage Kubernetes applications. Helm Charts help you define, install, and upgrade even the most complex Kubernetes application.

Here's how you can achieve this using Pulumi with TypeScript:

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as k8s from "@pulumi/kubernetes";
import * as azuread from "@pulumi/azuread";
import * as random from "@pulumi/random";

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

// Step 2: Create an AD service principal for the AKS cluster
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
}).result;
const adApp = new azuread.Application("aks");
const adSp = new azuread.ServicePrincipal("aksSp", {
    applicationId: adApp.applicationId,
});
const adSpPassword = new azuread.ServicePrincipalPassword("aksSpPassword", {
    servicePrincipalId: adSp.id,
    value: password,
    endDate: "2099-01-01T00:00:00Z",
});

// Step 3: Create the AKS cluster
const k8sCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfile: {
        name: "aksagentpool",
        count: 1,
        vmSize: "Standard_D2_v2",
    },
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "<YOUR_SSH_PUBLIC_KEY>",
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
    kubernetesVersion: "1.18.14",
});

// Step 4: Export the KubeConfig
export const kubeConfig = k8sCluster.kubeConfigRaw;

// Step 5: Create a Kubernetes provider instance using the generated kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: k8sCluster.kubeConfigRaw,
});

// Step 6: Deploy the Quarkus Helm chart
const quarkusChart = new k8s.helm.v3.Chart("quarkus-helm-chart", {
    chart: "quarkus",
    version: "1.0.0", // Specify the version you wish to deploy
    fetchOpts: {
        repo: "https://helm.quarkus.io/",
    },
}, { provider: k8sProvider });

// Step 7 (Optional): Export the public Service endpoint
export const frontendIp = quarkusChart.getResourceProperty("v1/Service", "quarkus-helm-chart-quarkus", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

Explanation:

We start off by creating a new resource group for our AKS cluster using azure.core.ResourceGroup.
We then create an Azure AD application and a service principal which are used by AKS for integration with Azure APIs.
We also create a password for the service principal using random.RandomPassword.
With the AD application and service principal, we can proceed to create the AKS cluster using azure.containerservice.KubernetesCluster. We're setting up an agent pool with a single virtual machine in this example.
The kubeConfig output gives you the configuration necessary to interact with your AKS cluster using kubectl.
A Kubernetes provider is then created using the kube config from our AKS cluster, which will allow us to deploy Kubernetes resources to it.
Using the Kubernetes provider, we deploy the Quarkus Helm chart with k8s.helm.v3.Chart. You need to specify your desire Helm chart version and the repository where the Quarkus Helm chart is stored.
Optionally, we export the loadBalancer IP address that can be used to access the Quarkus service.

Please replace <YOUR_SSH_PUBLIC_KEY> with your actual SSH public key.

Keep in mind that this is a basic example. Depending on your needs, you may need to adjust the AKS configuration, such as the location, the VM size, and the number of VM nodes. Additionally, make sure the Helm chart version matches with one provided by the Quarkus Helm repository.

Before running this program, ensure you have the necessary permissions to create resources in your Azure subscription and that you've set up the Pulumi Azure provider and authenticated with Azure CLI on your local machine.