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

Question

Pulumi · Accepted Answer

To deploy the WordPress Helm chart on Azure Kubernetes Service (AKS), you'll first need to set up an AKS cluster, and then you can deploy WordPress using the Helm chart. The following steps are involved:

1. **Set up an AKS cluster**: You will use Pulumi to provision an Azure Kubernetes Service cluster which will host your WordPress application.

2. **Install WordPress using Helm Chart**: Once the AKS cluster is up and running, you will install WordPress using its Helm chart. This is a package containing all necessary Kubernetes resources for running WordPress.

Let's start by creating a new Pulumi program in TypeScript to set up the AKS cluster. I'll explain each part of the program as we go.

### Step 1: Create an AKS cluster

First, you need to create an AKS cluster. To do this we'll use `azure-native` which is the Pulumi provider for Azure resources. The `ManagedCluster` resource from the `containerservice` module represents an AKS cluster.

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

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

// Create an AKS cluster
const cluster = new azure_native.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        vmSize: "Standard_DS2_v2",
        name: "agentpool",
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.20.7",
});

// Export the kubeconfig
export const kubeconfig = cluster.kubeConfig.apply(c => Buffer.from(c.apply(x => x.kubeConfig)).toString());
```

Here we're creating a resource group and an AKS cluster with three nodes of size `Standard_DS2_v2`. RBAC is enabled for the cluster and we're exporting the kubeconfig, which will allow us to interact with the cluster once it's provisioned.

### Step 2: Deploy WordPress using Helm Chart

Next, we'll use the `Chart` resource from the `k8s` module (Pulumi Kubernetes provider), which allows us to deploy Helm charts. For deploying WordPress, we'll specify the repository and chart name.

```typescript
// Helm chart for WordPress
const wordpressChart = new k8s.helm.v3.Chart("wordpress", {
    chart: "wordpress",
    version: "9.0.3", // specify the exact chart version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Values from the default WordPress Helm chart
    values: {
        mariadb: {
            authorization: {
                database: "wordpress",
                username: "wordpress",
                password: "wordpress",
            },
        },
    },
    // Ensure that the AKS cluster is ready before deploying
    transformations: [
        (obj: any) => {
            if (obj.spec && obj.spec.template && obj.spec.template.metadata) {
                obj.spec.template.metadata.annotations = obj.spec.template.metadata.annotations || {};
                obj.spec.template.metadata.annotations["pulumi.com/autonaming"] = "true";
            }
        },
    ],
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });
```

In this code block, we're creating a new instance of a Helm chart to deploy WordPress. The `fetchOpts` is where you specify the repository URL, and under `values`, you can configure the WordPress application, such as the database credentials.

Note the `transformations` field – it's a Pulumi feature enabling customization of the resources created by the Helm chart. Here, it ensures the resources are appropriately named for clarity.

Lastly, the `{ provider: ... }` option tells Pulumi to use the AKS cluster we created previously as the deployment target for this Helm chart.

Now let's put everything together in a single program:

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

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

// Create an AKS cluster
const cluster = new azure_native.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        vmSize: "Standard_DS2_v2",
        name: "agentpool",
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.20.7",
});

// Export the kubeconfig
const kubeconfig = cluster.kubeConfig.apply(c => Buffer.from(c.apply(x => x.kubeConfig)).toString());

// Deploy WordPress using Helm Chart
const wordpressChart = new k8s.helm.v3.Chart("wordpress", {
    chart: "wordpress",
    version: "9.0.3", // specify the exact chart version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Values from the default WordPress Helm chart
    values: {
        mariadb: {
            authorization: {
                database: "wordpress",
                username: "wordpress",
                password: "wordpress",
            },
        },
    },
    // Ensure that the AKS cluster is ready before deploying
    transformations: [
        (obj: any) => {
            if (obj.spec && obj.spec.template && obj.spec.template.metadata) {
                obj.spec.template.metadata.annotations = obj.spec.template.metadata.annotations || {};
                obj.spec.template.metadata.annotations["pulumi.com/autonaming"] = "true";
            }
        },
    ],
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the WordPress URL
export const wordpressUrl = wordpressChart.getResourceProperty("v1/Service", "wordpress", "status")
    .apply(status => `http://${status.loadBalancer.ingress[0].ip}/`);
```

This code creates an AKS cluster and then deploys WordPress on it via its Helm chart. The program exports the WordPress URL that you can use to access your WordPress instance once it's up and running.

To run this Pulumi program, you'll need Node.js and `@pulumi/pulumi`, `@pulumi/azure-native`, and `@pulumi/kubernetes` installed. Save the code to a file named `index.ts`, then run `pulumi up` to create the resources. After the deployment completes, you will see the `wordpressUrl` output, which you can navigate to in a web browser to view your WordPress site.