Deploy the kube-wordpress-mysql helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the kube-wordpress-mysql Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, we will accomplish several tasks:

1. Provision an AKS cluster.
2. Install the Helm chart for WordPress and MySQL.

Let's break down the steps with an explanation of the Pulumi resources used:

- **AKS Cluster (`azure-native.hybridcontainerservice.ProvisionedCluster`)**: This resource creates an AKS cluster, which is a managed Kubernetes service in Azure. You can specify various configurations such as the node size, number of nodes, and Kubernetes version.
  
- **Helm Chart (`kubernetes.helm.sh/v3.Chart`)**: Once the AKS cluster is provisioned, we can deploy applications onto it using Helm charts. Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications.

### Pulumi Program in TypeScript:

First, ensure you have completed the following prerequisites:

- Installed Pulumi CLI and set up Azure credentials.
- Installed Node.js and the Pulumi Node.js SDK.
- Installed the Helm CLI on your machine, as we will be deploying a Helm chart.

Now, let's walk through the Pulumi TypeScript program that accomplishes the deployment:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azureNative from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";

// Create an Azure Resource Group
const resourceGroup = new azureNative.resources.ResourceGroup("myResourceGroup");

// Create an AKS cluster
const cluster = new azureNative.hybridcontainerservice.ProvisionedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    identity: {
        type: "SystemAssigned",
    },
    location: resourceGroup.location,
    properties: {
        controlPlane: {
            count: 1,
            vmSize: "Standard_DS2_v2",
        },
        kubernetesVersion: "1.18.14",
    },
});

// Export the Kubeconfig
export const kubeconfig = cluster.properties.controlPlane.kubeconfig;

// Use the Kubeconfig to create a Kubernetes provider instance
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the kube-wordpress-mysql Helm chart
const wordpressHelmChart = new k8s.helm.v3.Chart("wordpress", {
    chart: "wordpress",
    version: "9.0.3", // Specify the version of the chart if required
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        // You can set chart values here, for example
        // mysql: {
        //     auth: {
        //         rootPassword: "secret-password",
        //     },
        // },
        // wordpress: {
        //     wordpressUsername: "admin",
        //     wordpressPassword: "admin-password",
        // },
    },
}, { provider: k8sProvider });

// Export the WordPress and MySQL service endpoint
export const frontendService = wordpressHelmChart.getResourceProperty("v1/Service", "wordpress", "status");
```

### Explanation of Pulumi Program:

- We start by importing the necessary Pulumi packages.
- We then create an Azure Resource Group, which is a container that holds related resources for an Azure solution.
- Next, we create an AKS cluster within the resource group. We configure it with system-assigned identity and define the necessary properties like the VM size and Kubernetes version.
- We export the cluster's kubeconfig, which will be used to interact with the AKS cluster using `kubectl` or other Kubernetes tooling.
- With the kubeconfig, we create a Kubernetes provider object. This provider will configure how Pulumi communicates with the Kubernetes cluster.
- We then define the deployment of the Helm chart named "wordpress", which installs WordPress and MySQL on the AKS cluster using the Bitnami Helm repository.
- Optionally, we can customize the chart's values, to configure database passwords or other settings. Please remember to use secrets for sensitive values.
- We create the `frontendService` export to make the WordPress front end accessible.

Remember to replace dummy values such as `wordpressPassword` with secure passwords, preferably managed using Pulumi's secret management.

After you write your Pulumi program in a file (for instance, `index.ts`), you can deploy it using the following Pulumi CLI commands:

```sh
pulumi up
```

After the Pulumi program executes, resources will be provisioned in your Azure account, and you'll receive endpoint URLs for your deployed WordPress site.