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

Question

Pulumi · Accepted Answer

To deploy the OpenMCT Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you need to perform several tasks:

Set up an Azure Kubernetes Service cluster.
Configure the Kubernetes provider to connect to your AKS cluster.
Use Pulumi's Kubernetes provider to deploy a Helm chart to the AKS cluster.

Below is a step-by-step Pulumi TypeScript program that accomplishes this:

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

// Create an AKS cluster
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    // Specifies the size of the AKS cluster, the location, and other parameters like the DNS prefix.
    resourceGroupName: "<Your Azure Resource Group Name>",
    location: "<Your Azure Location>", // Example: "West US"
    defaultNodePool: {
        vmSize: "Standard_DS2_v2", // Specifies the size of the VMs in the AKS cluster.
        maxPods: 110, // Specifies the max number of pods that can run on a single node.
        name: "aksnodepool", // Name of the node pool
        nodeCount: 2, // Number of nodes in the node pool
    },
    dnsPrefix: `<Your DNS Prefix>`, // DNS prefix for the AKS cluster
    // Other required properties like the service principal (you need to provide your own service principal or use Managed Identity)
    servicePrincipal: {
        clientId: "<Your Service Principal Client ID>",
        clientSecret: "<Your Service Principal Client Secret>",
    },
    linuxProfile: { // Configuration for access to the Linux VMs in the cluster
        adminUsername: "adminuser",
        sshKey: {
            keyData: `<Your SSH Public Key>`, // SSH public key for secure access to AKS nodes
        },
    },
    // Enable role-based access control for cluster security and management
    roleBasedAccessControlEnabled: true,
    kubernetesVersion: "1.18.14", // Specify the version of Kubernetes to use for the AKS cluster
});

// Export the kubeconfig of the AKS cluster
export const kubeconfig = aksCluster.kubeConfigRaw;

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

// Deploy the OpenMCT Helm chart to the AKS cluster using the Kubernetes provider
const openmctChart = new k8s.helm.v3.Chart("openmct", {
    repo: "helm_chart_repository_here", // Specify the Helm chart repository where OpenMCT is hosted
    chart: "openmct", // The name of the chart in the repository
    version: "chart_version_here", // The version of the OpenMCT chart to deploy
    // Values to configure the OpenMCT Helm chart
    values: {
        // Configure the necessary values for OpenMCT chart deployment
        // For example, you might want to set the service type to LoadBalancer to expose OpenMCT to the internet
        service: {
            type: "LoadBalancer",
        },
        // Add any other necessary configuration for OpenMCT here
    },
}, { provider: k8sProvider }); // Make sure you reference the provider created earlier to connect to your AKS

// Export the OpenMCT service endpoint
export const openmctServiceEndpoint = openmctChart.getResourceProperty("v1/Service", "openmct", "status");

Explanation:

The first part of the program uses Pulumi's Azure provider to create an AKS cluster. You need to replace placeholders like <Your Azure Resource Group Name>, <Your Azure Location>, and service principal information with your specific Azure details.
The AKS cluster configuration specifies the node size, location, and access details. The roleBasedAccessControlEnabled: true enables Kubernetes RBAC for the cluster.
The kubeconfig is exported so that you can use it to interact with your cluster from the command line later if required.
A Kubernetes provider is then instantiated using the exported kubeconfig. This provider will manage the OpenMCT deployment.
The OpenMCT Helm chart is then deployed to the AKS cluster using Pulumi's Kubernetes provider. Replace helm_chart_repository_here with the actual Helm repository URL for OpenMCT, and chart_version_here with the version of the OpenMCT Helm chart you wish to install.
Lastly, the program exports the service endpoint that can be used to access the OpenMCT application once it's deployed.

Make sure to replace all placeholder values with your actual Azure and OpenMCT Helm chart details before running this Pulumi program.

After you have your index.ts file ready and have replaced the placeholder values with real ones, you can run pulumi up from your command line in the directory where your Pulumi program file is located to deploy the OpenMCT Helm chart on AKS.

Pulumi will prompt you for confirmation before making any changes to your cloud resources. Once executed, Pulumi will output any exported variables like kubeconfig and openmctServiceEndpoint.