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

Question

Pulumi · Accepted Answer

To deploy the kube-wordpress-mysql Helm chart on an Azure Managed OpenShift Service using Pulumi, you will first need to set up the OpenShift Managed Cluster resource. Then, using the Kubernetes provider, you can deploy the Helm chart to the cluster. Below is the detailed process and the corresponding Pulumi program in TypeScript.

### Deploy an Azure OpenShift Managed Cluster

First, we deploy the OpenShift Managed Cluster in Azure with the `azure-native.containerservice.OpenShiftManagedCluster` resource. This resource represents a managed OpenShift cluster in Azure, which simplifies running containerized applications without container orchestration expertise.

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

const managedCluster = new azure.containerservice.OpenShiftManagedCluster("myOpenshiftCluster", {
    // Required properties
    location: "East US",   // example location, should be based on your requirement
    resourceName: "myOpenshiftCluster",
    resourceGroupName: "myResourceGroup", // assumes an existing resource group
    openShiftVersion: "3.11", // specify the OpenShift version
    networkProfile: {
        vnetCidr: "10.0.0.0/8"
    },
    masterPoolProfile: {
        count: 3,          // number of master nodes
        vmSize: "Standard_D4s_v3",   // virtual machine size for master nodes
    },
    // Other necessary configurations like agent pools go here
});
```

### Deploy the Helm Chart to the Cluster

After the OpenShift Managed Cluster is deployed, you can deploy the Helm chart to the cluster. First, you need to configure the Kubernetes provider to connect to the newly created Azure OpenShift cluster. This usually involves setting up the `kubeconfig` which is used by Kubernetes clients to connect to the Kubernetes API server.

```typescript
import * as k8s from "@pulumi/kubernetes";

// Kubernetes provider to connect to the Azure OpenShift cluster
const provider = new k8s.Provider("myK8sProvider", {
    kubeconfig: managedCluster.config.apply(JSON.stringify), // kubeconfig is obtained from the managed cluster
});

// Deploy kube-wordpress-mysql Helm chart
const wordpress = new k8s.helm.v3.Chart("kube-wordpress-mysql", {
    chart: "wordpress",
    version: "9.0.3",   // specify the chart version if needed
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider });
```

By setting the `provider` option in the `Chart` resource, you're telling Pulumi that this Helm chart should be deployed using the Kubernetes provider we've created to connect to our OpenShift cluster.

This example assumes that the `kube-wordpress-mysql` Helm chart is from the Bitnami Helm repository. You should replace the `chart` and `version` with the appropriate chart name and version you wish to deploy.

### Full Pulumi Program

Here is the full Pulumi TypeScript program combining the steps above to deploy an Azure OpenShift Managed Cluster and then deploying the `kube-wordpress-mysql` Helm chart to that cluster.

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

// Create an Azure resource (OpenShift Managed Cluster)
const managedCluster = new azure.containerservice.OpenShiftManagedCluster("myOpenshiftCluster", {
    // Required properties
    location: "East US",   // example location, should be based on your requirement
    resourceName: "myOpenshiftCluster",
    resourceGroupName: "myResourceGroup", // assumes an existing resource group
    openShiftVersion: "3.11", // specify the OpenShift version
    networkProfile: {
        vnetCidr: "10.0.0.0/8"
    },
    masterPoolProfile: {
        count: 3,          // number of master nodes
        vmSize: "Standard_D4s_v3",   // virtual machine size for master nodes
    },
    // Other necessary configurations like agent pools go here
});

// Create a Kubernetes provider instance that uses the cluster's kubeconfig
// Assume that `managedCluster.config` is the output property containing the kubeconfig
const k8sProvider = new k8s.Provider("myK8sProvider", {
    kubeconfig: managedCluster.config.apply(JSON.stringify),
});

// Deploy kube-wordpress-mysql Helm chart using the Kubernetes provider
const wordpress = new k8s.helm.v3.Chart("kube-wordpress-mysql", {
    chart: "wordpress",
    version: "9.0.3",   // specify the chart version if needed
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the public IP to access the Wordpress application
export const frontendIp = wordpress.getResourceProperty("v1/Service", "kube-wordpress-mysql-wordpress", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

In this program, you can see that we configure the Azure OpenShift Managed Cluster and connect a Kubernetes provider to it. Afterward, we deploy the Helm chart to the OpenShift cluster using Pulumi's Kubernetes provider. Finally, we export the front-end IP address, which should eventually be the public IP address of the WordPress service in the OpenShift cluster, giving you access to your WordPress site.

Make sure you have the Pulumi CLI installed and configured with your Azure account, and have the required permissions to create resources in the Azure subscription. Then, to run the above program:

1. Save the code to a file called `index.ts`.
2. Run `pulumi stack init` to create a new stack.
3. Run `pulumi up` to preview and deploy your resources.

The `pulumi up` command creates the OpenShift cluster followed by the WordPress application and a MySQL database as defined in the `kube-wordpress-mysql` Helm chart. Please consult the relevant Azure documentation for any specific permissions and roles required to create the cluster, and to Helm chart documentation for any custom configurations for the WordPress and MySQL deployments.