Deploy the kube-wordpress-mysql helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the kube-wordpress-mysql Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'll have to follow these high-level steps:

Create a GKE cluster: We will start by defining a GKE cluster where your applications will run.
Install the Helm chart: Once we have the Kubernetes cluster, we will deploy the kube-wordpress-mysql Helm chart to the cluster.

For this task, we will use the gcp.container.Cluster resource from the Pulumi GCP provider to create the GKE cluster. After the cluster is created, we will use the pulumi/kubernetes package to interact with the Kubernetes cluster and deploy the Helm chart.

Below is a comprehensive TypeScript program that accomplishes the deployment of the kube-wordpress-mysql Helm chart to a GKE cluster using Pulumi:

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Create the GKE cluster
const cluster = new gcp.container.Cluster("wp-cluster", {
    // You can customize the cluster by setting additional properties here.
    initialNodeCount: 2,
    minMasterVersion: "latest", // Specifies the version of the master.
    nodeVersion: "latest", // Specifies the version of the nodes.
    nodeConfig: {
        // Use a machine type that meets your requirements.
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
});

// Export the cluster name and kubeconfig for easy access to the cluster.
export const clusterName = cluster.name;
export const kubeConfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

// Step 2: Install the kube-wordpress-mysql helm chart
const wordpressChart = new k8s.helm.v3.Chart("wp-helm-chart", {
    chart: "wordpress",
    version: "10.0.4", // Use the specific version that suits your requirements.
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Pass the required parameters to the chart here.
    values: {
        // Set different values that the wordpress Helm chart expects.
        // This is a hypothetical example, see the chart values for required parameters.
        // https://artifacthub.io/packages/helm/bitnami/wordpress
        mariadb: {
            auth: {
                rootPassword: "your-root-password",
                database: "wordpress_db",
                username: "wp_user",
                password: "your-wp-password",
            },
        },
        wordpressUsername: "admin",
        wordpressPassword: "your-admin-password",
        wordpressEmail: "admin@example.com",
    },
    // The namespace where the chart will be installed.
    namespace: "default",
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeConfig }) });

// Export the WordPress Service URL by querying the Kubernetes Service detail after it's created.
export const wordpressServiceUrl = wordpressChart.getResourceProperty("v1/Service", "wp-helm-chart-wordpress", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

Explanation:

First, we create a new GKE cluster using gcp.container.Cluster. We specify the node count, the master and nodes version, the machine type, and scopes. You should adjust the machineType and other properties based on your resource needs and requirements.
We also export the kubeconfig, which is needed to interact with the Kubernetes cluster using Pulumi or kubectl.
After creating the GKE cluster, we define a new Helm chart resource wordpressChart using the k8s.helm.v3.Chart class. Here we specify the chart name, version, repository, and customized values that the WordPress chart requires, such as database credentials and admin details.
We use the chart's defaults for all other configuration parameters for the sake of simplicity in this example, but you might need to customize other configuration parameters like serviceType, ingress, or resource requests and limits based on your environment and needs.
Lastly, we export the WordPress service URL, which you can use to access your newly deployed WordPress site once the load balancer gets an external IP assigned.

Please adjust the sensitive data like passwords in the chart values to your own secure values or use secret management for production deployment.

The kube-wordpress-mysql chart used in this example is a hypothetical name for the WordPress Chart which usually comes in the format <repo>/<chart>, with the official repository often being 'bitnami' for WordPress. If the chart name is not exactly "kube-wordpress-mysql", please replace it with the correct name from the Helm repository you are using.

The Pulumi program provided here would provide outputs including the cluster name, the kubeconfig to access the cluster, and the URL for the WordPress service. Use these outputs to manage your cluster and access your WordPress site.