Deploy the wordpress-helm-chart helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

Deploying a WordPress application using the Helm chart on Azure Red Hat OpenShift involves several steps. We will first need to instantiate the Openshift cluster in Azure and then deploy the WordPress Helm chart onto the cluster.

Here's a breakdown of the process:

1. **Create the OpenShift Managed Cluster**: Use the `azure-native.redhatopenshift.OpenShiftCluster` resource to create an OpenShift cluster in Azure. You need to provide various details such as the location, resource group name, cluster profile, and network profile.

2. **Install the Helm Chart for WordPress**: After the cluster is up and running, we will use the `kubernetes.helm.sh/v3.Chart` resource to deploy the WordPress application using its Helm chart.

Below is the full Pulumi program written in TypeScript that performs these tasks. Note that you need to have Pulumi configured with Azure credentials and have Helm installed on your system for the following code to work.

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

// Instantiate an Azure Resource Group for our resources
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "my-rg",
    location: "East US", // choose an appropriate Azure region here
});

// Create an Azure Red Hat OpenShift cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster("myOpenshiftCluster", {
    resourceGroupName: resourceGroup.name,
    resourceName: "myCluster",
    location: resourceGroup.location,
    clusterProfile: {
        pullSecret: pulumi.interpolate`{"auths": {}}`, // Your Red Hat pull secret
        domain: "example.com",
        version: "4.3.0", // specify the OpenShift version
    },
    masterProfile: {
        vmSize: "Standard_D16s_v3",
    },
    workerProfiles: [{
        name: "worker",
        vmSize: "Standard_D4s_v3",
        count: 3,
    }],
    networkProfile: {
        podCidr: "10.128.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
    tags: {
        environment: "production",
    },
});

// Kubernetes provider to interact with the OpenShift cluster
const openshiftK8sProvider = new kubernetes.Provider("openshiftK8sProvider", {
    kubeconfig: openshiftCluster.kubeconfig.apply(JSON.stringify),
});

// Deploy WordPress using the Helm chart
const wordpressHelmChart = new kubernetes.helm.v3.Chart("wordpress", {
    chart: "wordpress",
    version: "9.0.3", // specify the chart version
    namespace: "default",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // You can provide additional custom values here
    values: {
        mariadb: {
            auth: {
                rootPassword: "my-root-password",
                database: "wordpress",
            },
        },
        wordpressUsername: "user",
        wordpressPassword: "pass",
        wordpressEmail: "user@example.com",
        wordpressFirstName: "FirstName",
        wordpressLastName: "LastName",
        wordpressBlogName: "My Blog!",
    },
}, { provider: openshiftK8sProvider });

// Export the Kubernetes cluster's kubeconfig
export const kubeconfig = openshiftCluster.kubeconfig;

// Export the WordPress service IP by querying the Kubernetes services
export const wordpressServiceIP = wordpressHelmChart.getResourceProperty("v1/Service", "wordpress", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

In this code, we:

- Set up the Azure Resource Group to house our OpenShift cluster.
- Define the OpenShift cluster configuration, ensuring we populate the `pullSecret` with your Red Hat pull secret and set the domain, OpenShift version, VM sizes for master and worker nodes, and the network CIDRs for pods and services.
- Create a Kubernetes provider that allows us to interact with the OpenShift cluster using its `kubeconfig`.
- Install the WordPress Helm chart on the cluster, specifying the chart, version, values, and the provider we initialized in the previous step.
- Lastly, we export the `kubeconfig` to allow access to the cluster, and the `wordpressServiceIP` to access the deployed WordPress service.

Please ensure you replace placeholders like `my-root-password`, `myCluster`, and the OpenShift version with the actual values that suit your scenario.

After writing this Pulumi program, you would run `pulumi up` to deploy the cluster and Helm chart to your Azure account. Post-deployment, you can use the exported `kubeconfig` to configure `kubectl` to communicate with the cluster and the `wordpressServiceIP` to access your WordPress site.