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

Question

Pulumi · Accepted Answer

To deploy the `typo3scan` Helm chart on Azure Kubernetes Service (AKS), you'll need to carry out several steps. First, you need to create an AKS cluster, which will serve as your managed Kubernetes environment. Once the cluster is set up, you can then deploy the `typo3scan` Helm chart into the cluster.

Here's a breakdown of the steps we'll take in the Pulumi TypeScript program:

1. **Set up an AKS cluster**: Define and configure your AKS cluster using the `azure.containerservice.KubernetesCluster` resource. Make sure the cluster has the necessary specifications to run your Helm chart.
   
2. **Deploy the Helm chart**: Use the `kubernetes.helm.v3.Chart` resource to deploy `typo3scan` to your AKS cluster.

Below is a Pulumi program written in TypeScript that accomplishes these steps. Please ensure that you have Pulumi installed and configured with your Azure credentials. Relevant Pulumi and Azure CLI tools should also be installed on your development machine.

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

// Create a resource group for the AKS cluster
const resourceGroup = new azure.core.ResourceGroup('aksResourceGroup');

// Create an Azure Active Directory application for the AKS cluster
const app = new azuread.Application("aks");

// Create a service principal for the application
const servicePrincipal = new azuread.ServicePrincipal("aksSp", { applicationId: app.applicationId });

// Create a random password for the service principal
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
});

// Create a service principal password for the application
const servicePrincipalPassword = new azuread.ServicePrincipalPassword("aksSpPassword", {
    servicePrincipalId: servicePrincipal.id,
    value: password.result,
    endDate: "2099-01-01T00:00:00Z",
});

// Create the AKS cluster using azure.containerservice.KubernetesCluster
const cluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        name: "aksagentpool",
        count: 3,
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "aksk8s",
    linuxProfile: {
        adminUsername: "aksuser",
        sshKeys: [{
            keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..."
        }]
    },
    servicePrincipal: {
        clientId: app.applicationId,
        clientSecret: servicePrincipalPassword.value,
    },
    kubernetesVersion: "1.18.14",
});

// Output the kubeconfig for the AKS cluster
export const kubeconfig = pulumi.all([cluster.name, resourceGroup.name]).apply(([clusterName, rgName]) => {
    return azure.containerservice.getKubeConfig({
        name: clusterName,
        resourceGroupName: rgName,
    });
});

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

// Deploy the typo3scan Helm chart on the AKS cluster using kubernetes.helm.v3.Chart
const typo3scanChart = new kubernetes.helm.v3.Chart("typo3scan", {
    chart: "typo3scan",
    version: "x.x.x", // Specify the chart version
    fetchOpts: {
        repo: "https://charts.your-repo.com", // Specify the Helm chart repository URL if not a public repo
    },
}, { provider: k8sProvider });

// Export the Chart name and status
export const typo3scanChartName = typo3scanChart.metadata.apply(m => m.name);
export const typo3scanChartStatus = typo3scanChart.status.apply(s => s.phase);

```

Remember to replace `"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..."` with your actual SSH public key and specify the correct `version` and `repo` for the `typo3scan` Helm chart.

Here's what the above code does:
- It creates a new resource group to hold the AKS resources.
- Then it sets up an Azure AD application and a service principal for the AKS cluster and generates a random password for authentication.
- Using the service principal details, it creates an AKS cluster with a specified node size and count.
- Once the AKS cluster is set up, it exports the kubeconfig to be used for setting up the Kubernetes provider for Pulumi.
- Finally, it deploys the `typo3scan` Helm chart to the AKS cluster using the Kubernetes provider.

Remember to install `@pulumi/azure`, `@pulumi/kubernetes`, `@pulumi/azuread`, and `@pulumi/random` packages using `npm` or `yarn` before running the program.

After the Pulumi program runs, it will output the name and deployment status of the `typo3scan` Helm chart. You can then use `kubectl` to interact with your AKS cluster and the installed `typo3scan` application.