Deploying WordPress on Google Kubernetes Engine (GKE)

Introduction

In today’s rapidly evolving landscape of containerized applications, deploying WordPress on Google Kubernetes Engine (GKE) offers unparalleled scalability and resilience. This guide serves as a comprehensive resource, detailing the steps involved in setting up a robust WordPress deployment paired with a MySQL database, utilizing Persistent Disk for storage, and leveraging Google Cloud SQL for efficient database management.

Pioneers in Cloud Consulting & Migration Services

Reduced infrastructural costs
Accelerated application deployment

Get Started

WordPress and Its Data Storage

WordPress relies heavily on relational databases for storing articles and metadata, as well as on local file systems for asset management. Given the transient nature of containers, storing persistent data within them is impractical. Persistent Disk provides a reliable solution, ensuring that data remains intact even in the event of container deletion.

Setting up your environment

To kickstart the setup process, configure Google Cloud Shell by setting the desired region and downloading the necessary application manifest files from the GitHub repository

gcloud config set compute/region <region>

1	gcloud config set compute/region <region>

Download the manifest files

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

1	git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

Creating a GKE cluster

Leverage Google Cloud Shell to create a GKE cluster tailored to host your WordPress application containers. Once created, establish a connection to the newly provisioned cluster to facilitate further configuration.

GKE_CLUSTER_NAME=<persistent-disk-wordpress>
gcloud container clusters create-auto $GKE_CLUSTER_NAME

1 2	GKE_CLUSTER_NAME=<persistent-disk-wordpress> gcloud container clusters create-auto $GKE_CLUSTER_NAME

gcloud container clusters get-credentials $GKE_CLUSTER_NAME --region REGION

1	gcloud container clusters get-credentials $GKE_CLUSTER_NAME --region REGION

Provicining PV and a PVC :

In order to achieve persistent data storage for the WordPress deployment, it’s imperative to create a Persistent Volume (PV) and a Persistent Volume Claim (PVC). Google Kubernetes Engine (GKE) simplifies this process by offering a default StorageClass resource, enabling dynamic provisioning of PVs backed by Persistent Disk.

PVC Creation Manifest:

We utilize the wordpress-volumeclaim.yaml file to describe our PVC. This manifest requests 200 GB of storage. Note that we haven’t explicitly defined a StorageClass resource in the file, implying the use of the default StorageClass for provisioning a PV backed by Persistent Disk.Command to deploy the manifest

kubectl apply -f $WORKING_DIR/wordpress-volumeclaim.yaml

1	kubectl apply -f $WORKING_DIR/wordpress-volumeclaim.yaml

Setting up Google Cloud SQL instance

SQL_INSTANCE_NAME= <mysql-wd-instance>
gcloud sql instances create $SQL_INSTANCE_NAME

1 2	SQL_INSTANCE_NAME= <mysql-wd-instance> gcloud sql instances create $SQL_INSTANCE_NAME

export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe $SQL_INSTANCE_NAME \
    --format='value(connectionName)')

1 2	export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe $SQL_INSTANCE_NAME \ --format='value(connectionName)')

gcloud sql databases create wordpress --instance $SQL_INSTANCE_NAME

1	gcloud sql databases create wordpress --instance $SQL_INSTANCE_NAME

Generate credentials for a database user named “wordpress” and assign a password for WordPress authentication to the instance:

CLOUD_SQL_PASSWORD=$(openssl rand -base64 18)
gcloud sql users create <wordpress> --host=% --instance $SQL_INSTANCE_NAME \
    --password $CLOUD_SQL_PASSWORD

CLOUD_SQL_PASSWORD=$(openssl rand -base64 18)

gcloud sql users create <wordpress> --host=% --instance $SQL_INSTANCE_NAME \

--password $CLOUD_SQL_PASSWORD

Deploying WordPress

Configure Service Account and Create Kubernetes Secrets:
Before proceeding with the deployment of WordPress, it’s essential to set up a service account and create Kubernetes secrets to manage both the service account and database credentials. This ensures secure communication between our WordPress application and the MySQL instance through a Google Cloud SQL proxy.

Create Service Account:
We begin by creating a service account named <cloudsql-proxy> using the Google Cloud CLI:

Service_Account_NAME=cloudsql-proxy
gcloud iam service-accounts create $Service_Account_NAME --display-name $Sservice_Account_NAME

1 2	Service_Account_NAME=cloudsql-proxy gcloud iam service-accounts create $Service_Account_NAME --display-name $Sservice_Account_NAME

This command establishes a dedicated service account for our deployment.

Extract Service Account Email:
We extract the service account’s email address and set it as an environment variable for later use:

Service_Account_EMAIL=$(gcloud iam service-accounts list \
    --filter=displayName:$Sservice_Account_NAME \
    --format='value(email)')

Service_Account_EMAIL=$(gcloud iam service-accounts list \

--filter=displayName:$Sservice_Account_NAME \

--format='value(email)')

Assign Required Role:
To enable the service account to interact with Google Cloud SQL, we add the cloudsql.client role:This step ensures the necessary permissions for the service account.

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --role roles/cloudsql.client \
    --member serviceAccount:$Service_Account_EMAIL

gcloud projects add-iam-policy-binding $PROJECT_ID \

--role roles/cloudsql.client \

--member serviceAccount:$Service_Account_EMAIL

Generate Key for Service Account:
Generate a key file named “key.json” for the service account to facilitate authentication and authorization access.

gcloud iam service-accounts keys create $WORKING_DIR/key.json \
    --iam-account $Service_Account_EMAIL

1 2	gcloud iam service-accounts keys create $WORKING_DIR/key.json \ --iam-account $Service_Account_EMAIL

Create Kubernetes Secrets:
We create two Kubernetes secrets to store MySQL and service account credentials securely:
For MySQL credentials:

kubectl create secret generic cloudsql-db-credentials \
    --from-literal username=wordpress \
    --from-literal password=$CLOUD_SQL_PASSWORD

kubectl create secret generic cloudsql-db-credentials \

--from-literal username=wordpress \

--from-literal password=$CLOUD_SQL_PASSWORD

For service account credentials:

kubectl create secret generic cloudsql-instance-credentials \
    --from-file $WORKING_DIR/key.json

1 2	kubectl create secret generic cloudsql-instance-credentials \ --from-file $WORKING_DIR/key.json

These confidential pieces of information are vital for securely handling the sensitive data necessary to facilitate the communication between WordPress and the underlying MySQL database.

Deploy WordPress on GKE

It’s time to deploy our WordPress container in the Google Kubernetes Engine (GKE) cluster. This involves utilizing the wordpress_cloudsql.yaml manifest file, which defines a Deployment creating a Pod with the WordPress container.

Manifest File Description:
The wordpress_cloudsql.yaml manifest file encapsulates the deployment configuration. It specifies a single Pod running a container with the WordPress instance. Here are the key components:

The container reads the WORDPRESS_DB_PASSWORD environment variable, which contains the cloudsql-db-credentials secret created earlier.
Configuration for communication with MySQL is facilitated through the Google Cloud SQL proxy running in a sidecar container. The WORDPRESS_DB_HOST environment variable is crucial in this setup.

Prepare and Deploy:
Before deployment, it’s essential to prepare the manifest file by replacing the <INSTANCE_CONNECTION_NAME> environment variable. This is achieved using the following commands:

cat $WORKING_DIR/wordpress_cloudsql.yaml.template | envsubst > \
    $WORKING_DIR/wordpress_cloudsql.yaml

1 2	cat $WORKING_DIR/wordpress_cloudsql.yaml.template \| envsubst > \ $WORKING_DIR/wordpress_cloudsql.yaml

We’re prepared to initiate the deployment of the WordPress container utilizing the manifest file.

kubectl create -f $WORKING_DIR/wordpress_cloudsql.yaml

1	kubectl create -f $WORKING_DIR/wordpress_cloudsql.yaml

Monitor Deployment Status:
The deployment process takes a few minutes as the manifest file orchestrates the attachment of a Persistent Disk to the compute node. To monitor the deployment status and ensure everything is running smoothly, use the following command.

kubectl get pod

1	kubectl get pod

Expose WordPress Service for External Access

In the preceding step, we successfully deployed the WordPress container; however, it’s currently secluded within your cluster without an external IP address. To make your WordPress app accessible from the internet, we’ll create and configure a Kubernetes Service with an attached external load balancer.

Service Exposure Configuration:

Utilizing the wordpress-service.yaml file, this configuration ensures external accessibility for your WordPress app. The Service is explicitly defined with the type LoadBalancer, indicating the need for an external load balancer.

Command to Create Service:

kubectl create -f $WORKING_DIR/wordpress-service.yaml

1	kubectl create -f $WORKING_DIR/wordpress-service.yaml

Monitor Service Creation:

The process of creating the load balancer takes a few minutes. Keep an eye on the deployment progress and wait for the Service to be assigned an external IP address. Utilize the following command:

kubectl get svc -l app=wordpress --watch

1	kubectl get svc -l app=wordpress --watch

When the output displays an external IP address, as illustrated below, you’re ready to move forward. Note that your external IP will differ from the example:
Sample Output:

NAME       CLUSTER-IP           EXTERNAL-IP    PORT(S)        AGE
wordpress   10.51.243.233   <xy3.0.1xy.3>    80:32418/TCP   1m

1 2	NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE wordpress 10.51.243.233 <xy3.0.1xy.3> 80:32418/TCP 1m

Setting up your WordPress blog

Now that your WordPress service is externally accessible, it’s time to configure and set up your WordPress blog.

Navigate to WordPress Installation Page

Using your preferred web browser, visit the following URL, replacing external-ip-address with the actual EXTERNAL_IP address assigned to your WordPress service,

http://external-ip-address

1	http://external-ip-address

Begin WordPress Installation:

Upon reaching the WordPress installation page, you’ll have the opportunity to choose your desired language. Simply select your preferred language and proceed by clicking on the “Continue” button.

Provide Essential Information:

Proceed to the “Information Needed” page. Here, we will be required to input crucial details for your WordPress blog, including the site title, username, password, and email address. Fill in the necessary information.

fig1

Finalize WordPress Installation:

Once you’ve filled in the necessary information, proceed by clicking the “Install WordPress” button to begin the installation process.

Log In to our WordPress Dashboard:

Access your WordPress dashboard by clicking on “Log In” after the installation is finished. Then, enter the username and password you set up earlier during the installation process.

fig2

Conclusion

Congratulations on successfully deploying WordPress on Google Kubernetes Engine (GKE) with Persistent Disk and Google Cloud SQL! This setup ensures data durability and availability, with Persistent Disk providing reliable storage outside the containers and Google Cloud SQL offering a managed MySQL database solution.

Drop a query if you have any questions regarding GKE and we will get back to you quickly.

Experience Effortless Cloud Migration with Our Expert Solutions

Stronger security
Accessible backup
Reduced expenses

Get Started

About CloudThat

CloudThat is a leading provider of Cloud Training and Consulting services with a global presence in India, the USA, Asia, Europe, and Africa. Specializing in AWS, Microsoft Azure, GCP, VMware, Databricks, and more, the company serves mid-market and enterprise clients, offering comprehensive expertise in Cloud Migration, Data Platforms, DevOps, IoT, AI/ML, and more.

CloudThat is recognized as a top-tier partner with AWS and Microsoft, including the prestigious ‘Think Big’ partner award from AWS and the Microsoft Superstars FY 2023 award in Asia & India. Having trained 650k+ professionals in 500+ cloud certifications and completed 300+ consulting projects globally, CloudThat is an official AWS Advanced Consulting Partner, AWS Training Partner, AWS Migration Partner, AWS Data and Analytics Partner, AWS DevOps Competency Partner, Amazon QuickSight Service Delivery Partner, Amazon EKS Service Delivery Partner, Microsoft Gold Partner, AWS Microsoft Workload Partners, Amazon EC2 Service Delivery Partner, and many more.

To get started, go through our Consultancy page and Managed Services Package, CloudThat’s offerings.

FAQs

1. Why use Persistent Disk for WordPress on GKE?

ANS: – Persistent Disk ensures that your WordPress data persists even if containers are deleted or moved. It provides a reliable storage solution outside the containers, enhancing data durability.

2. What is the role of Google Cloud SQL in this deployment?

ANS: – Google Cloud SQL serves as the managed MySQL database for WordPress. It replaces the traditional installation of MySQL, offering a scalable and fully managed database solution for your WordPress application.

WRITTEN BY Deepakraj A L

Deepakraj A L works as a Research Intern at CloudThat. He is learning and gaining practical experience in AWS and Azure. Deepakraj is also passionate about continuously expanding his skill set and knowledge base by actively seeking opportunities to learn new skills. Deepakraj regularly explores blogs and articles related to various programming languages, technologies, and industry trends to stay up to date with the latest development in the field.