Deploy the old-joomla helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `old-joomla` Helm chart on Azure Kubernetes Service (AKS), you'll need to create the AKS cluster, set up Helm support, and deploy the chart into your cluster. Pulumi's Kubernetes library can be used to interact with Helm charts, allowing you to deploy applications managed by Helm into your clusters.

Here's a step-by-step guide to achieve this:

1. **Set up an AKS Cluster**: You'll use the `azure-native.containerregistry.KubernetesCluster` resource to create an AKS cluster, which provides Kubernetes-as-a-Service on Azure.

2. **Configure Helm Release**: You'll use the `kubernetes.helm.v3.Chart` resource, which is a Pulumi resource that represents a Helm chart and allows you to deploy it.

Before running the following Pulumi program, make sure that:

- You have Pulumi CLI installed and configured with Azure credentials.
- You have Helm CLI installed, as Pulumi uses it to deploy Helm charts.
  
```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as k8s from "@pulumi/kubernetes";

// Create an AKS cluster.
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: "yourResourceGroupName",
    location: "West US",
    defaultNodePool: {
        name: "aksagentpool",
        minCount: 3,
        maxCount: 5,
        vmSize: "Standard_D2_v2",
    },
    dnsPrefix: "aksClusterDns",
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa AAAA....",
        },
    },
    servicePrincipal: {
        clientId: "yourServicePrincipalClientId",
        clientSecret: "yourServicePrincipalClientSecret", // Consider using secret config to avoid exposing sensitive data
    },
    kubernetesVersion: "1.22.10", // Use an appropriate version for your use case
});

// Export the kubeconfig.
export const kubeconfig = aksCluster.kubeConfigRaw;

// Create a provider to handle Helm charts.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Deploy the old-joomla Helm chart into the cluster.
const joomlaChart = new k8s.helm.v3.Chart("old-joomla", {
    chart: "joomla",
    version: "5.1.4", // Use the correct chart version that matches 'old-joomla'
    namespace: "default", // Deploy chart in the 'default' namespace or specify a custom namespace
}, { provider: k8sProvider });

// Export the public endpoint of Joomla.
export const joomlaEndpoint = joomlaChart.getResourceProperty("v1/Service", "old-joomla", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program:

- We create an AKS cluster with a node pool ranging from 3 to 5 virtual machines of size `Standard_D2_v2`. Feel free to adjust the `location`, `resourceGroupName`, `dnsPrefix`, and other properties to match your requirements.
- The `kubeconfig` is exported to allow you to interact with your AKS cluster using the `kubectl` command-line tool.
- We create a Pulumi Kubernetes provider using the output kubeconfig of the AKS cluster. This provider is then used to manage resources inside the Kubernetes cluster.
- Finally, we deploy the `old-joomla` Helm chart. You should replace `version` with the correct version that contains the older Joomla you want to install. Adjust `namespace` if you have a specific Kubernetes namespace where you’d like to deploy the application. If you don't specify it, Pulumi will install the Helm chart in the `default` namespace.
- We try to export the Joomla endpoint which should give you the public IP address where you can access your Joomla installation. Note that it might take some time for the IP to be available after the Helm chart is deployed. Ensure that your Helm chart exposes Joomla on a LoadBalancer service type for this to work.

Remember to replace placeholder values with your actual resources and credentials. Additionally, sensitive data such as secrets should be handled using Pulumi's secret management.

To run the program, you should navigate to the directory containing the `index.ts` file and use the following commands:

```bash
# Install the Pulumi Azure plugin
pulumi plugin install resource azure v5.52.0

# Install the Pulumi Kubernetes plugin
pulumi plugin install resource kubernetes v4.4.0

# Install necessary NPM packages
npm install

# Preview and run the deployment
pulumi up
```

The output will show you a preview of the resources Pulumi plans to create. If everything looks correct, you can proceed with the update to actually create the resources in Azure.