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

Question

Pulumi · Accepted Answer

To deploy the Signal Sciences helm chart on Azure Kubernetes Service (AKS), we will follow these steps:

Set up AKS Cluster: To deploy Signal Sciences, we need a Kubernetes cluster. Here we will set up AKS, which is a managed container orchestration service provided by Azure.
Install Helm on Cluster: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications.
Deploy Signal Sciences Helm Chart: Once we have Helm set up, we can add the Signal Sciences Helm repository and deploy the chart to the cluster.

Below is a step-by-step Pulumi TypeScript program that will set up the AKS cluster, install Helm, and deploy the Signal Sciences helm chart.

Make sure before you start, you have Pulumi installed and configured with Azure credentials. You will also need Node.js and npm installed to be able to run this Pulumi program.

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 a new Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "WestUS",
});

// Step 2: Create an Azure AD Application for AKS
const app = new azuread.Application("aks", {});

// Step 3: Create a Service Principal for the Application
const sp = new azuread.ServicePrincipal("aksSp", {
    applicationId: app.applicationId,
});

// Step 4: Create the AKS cluster itself
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
}).result;

const k8sCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        name: "agentpool",
        count: 3,
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "<SSH PUBLIC KEY>",
        },
    },
    servicePrincipal: {
        clientId: app.applicationId,
        clientSecret: password,
    },
    kubernetesVersion: "1.18.14",
});

// Step 5: Export the kubeconfig
export const kubeconfig = pulumi.all([resourceGroup.name, k8sCluster.name]).apply(([name, clusterName]) =>
  azure.containerservice.getKubeConfig({
      name: clusterName,
      resourceGroupName: name,
  }));

// Step 6: Create a k8s provider using the above kubeconfig
const provider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Step 7: Deploying the Signal Sciences Helm Chart
const signalsciencesChart = new k8s.helm.v3.Chart("signalsciences", {
    chart: "signalsciences",
    // Replace the values below with the appropriate configurations
    values: {
        // ... specific Signal Sciences configurations ...
    },
    fetchOpts: {
        repo: "https://helm.signalsciences.net",
    },
}, { provider: provider });

// Step 8: Export the K8s cluster name
export const clusterName = k8sCluster.name;

// Step 9: Export the Signal Sciences service endpoint if necessary
export const signalsciencesEndpoint = signalsciencesChart.getResourceProperty("v1/Service", "signalsciences", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

How to use this code:

Save this code in a index.ts file.
Replace <SSH PUBLIC KEY> with your actual SSH public key.
Update the values in the signalsciencesChart resource with the appropriate configurations for deploying Signal Sciences.
Run pulumi up in the same directory as your index.ts. Pulumi CLI will execute the TypeScript program to deploy your infrastructure.

The above program performs the following actions:

Creates a new Azure resource group within which all resources will reside.
Sets up an Azure AD application and a corresponding service principal to establish identity for AKS.
Deploys an AKS cluster with a specified DNS prefix and agent pool configuration.
Generates a secure random password for the service principal.
Retrieves the kubeconfig from Azure to interact with the cluster.
Initializes a Kubernetes provider with the kubeconfig.
Deploys the Signal Sciences helm chart from its Helm repository onto the AKS cluster using the Kubernetes provider.

Remember to fill in the appropriate values for your Signal Sciences configuration in the signalsciencesChart resource before running the Pulumi program. The values field should contain all the necessary configurations appropriate for deploying Signal Sciences in your context.

After deployment, you can manage Signal Sciences through Kubernetes tooling like kubectl or the Azure portal. The service endpoint (if relevant) which is typically the external IP for accessing Signal Sciences dashboard, will be exported as signalsciencesEndpoint.