Deploy the Wordress helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a WordPress Helm chart on Google Kubernetes Engine (GKE) involves a few high-level steps which include creating a GKE cluster, setting up Helm (the Kubernetes package manager), and then deploying WordPress using a Helm chart.

Below is a step-by-step guide on how you would implement this using Pulumi with TypeScript:

1. **Set up a GKE cluster**: You need a Kubernetes cluster running on GKE to deploy your WordPress application. This can be achieved using Pulumi's `google-native.container/v1.Cluster` resource, which allows you to provision a GKE cluster programmatically.

2. **Configure kubectl**: Once the cluster is up, you need to configure kubectl to communicate with it. Pulumi will set up the kubeconfig file for you automatically, which kubectl can use to access the GKE cluster.

3. **Install Helm**: Helm must be installed to deploy applications using Helm charts. Pulumi can streamline this by managing Helm releases directly with `kubernetes.helm.v3.Release` resources.

4. **Deploy WordPress**: With everything set up, you can deploy WordPress using the stable WordPress Helm chart. You will use the `kubernetes.helm.v3.Release` resource to deploy your Helm chart pointing it to the WordPress chart's repository and specifying necessary values such as user credentials or resource requirements.

Let's translate this to a Pulumi TypeScript program:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("wordpress-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    masterAuth: {
        clientCertificateConfig: {
            issueClientCertificate: false,
        },
    },
    nodeConfig: {
        preemptible: false,
        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
export const clusterName = cluster.name;

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy a WordPress Helm release using the Helm provider
const wordpressRelease = new kubernetes.helm.v3.Release("wordpress-release", {
    chart: "wordpress",
    version: "9.0.3", // Use the correct chart version
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami", // The repository for the WordPress Helm chart
    },
    values: { // Custom values for the WordPress chart
        mariadb: {
            auth: {
                rootPassword: "rootpassword",
                database: "wordpressdb",
                username: "wordpressuser",
                password: "wordpresspassword",
            },
        },
    },
}, { provider: k8sProvider });

// Export the WordPress instance endpoint to access your deployment.
export const wordpressFrontend = pulumi.all([cluster.name, wordpressRelease.status]).apply(([name, status]) => {
    if (status.loadBalancer.ingress[0]) {
        // If an ingress is available, return the IP.
        return status.loadBalancer.ingress[0].ip;
    } else {
        // If not, the service is probably still provisioning.
        return "Waiting for LoadBalancer IP...";
    }
});
```

Here’s a breakdown of what each part of the code is doing:
- We start by importing the required Pulumi packages.
- We create a new GKE cluster resource with the desired configuration such as node count, machine type, and OAuth scopes.
- We then provide the configuration to create an instance of the Kubernetes provider using our newly created GKE cluster.
- Next, we define a new Helm chart release targeting the `wordpress` chart from the Bitnami repository. We override default chart values like database credentials.
- Lastly, we export the cluster name and the endpoint of the WordPress installation. The `export` statement in Pulumi is used to output the computed values once the deployment is complete.

To deploy this Pulumi program, you should have Pulumi CLI installed and GCP set up with appropriate credentials. Running `pulumi up` in the directory where this code is saved will start provisioning the GKE cluster and deploying WordPress to it.