DEV Community: Raquel Campuzano Godoy

Deploy a Custom WordPress Image on a Kubernetes Cluster Using Bitnami Helm Charts

Raquel Campuzano Godoy — Wed, 29 Jan 2020 17:34:42 +0000

Originally published at docs.bitnami.com.

In the first part of this series, we have learned how to modify a Bitnami Docker WordPress image to include a custom plugin and a theme from the first run.

The last step we performed was to push our image to Docker Hub for having it available to use and ready to deploy on a Kubernetes cluster. Let's continue moving our WordPress site to a production scenario!

Helm charts: Ready-To-Deploy Applications

Helm charts are packages of pre-configured Kubernetes resources. A Helm chart describes how to manage a specific application on Kubernetes.

For easy and fast deployment of any containerized application on Kubernetes, the use of Helm charts are a savvy choice. Each chart includes references (Docker-compatible) to the container images that contain the application code to be run.

Based on a custom WordPress container, this tutorial shows how to make the necessary tweaks in the Bitnami WordPress Helm chart's values.production.yaml file to run your application in a production environment.

Set Up Prerequisites

Before starting, make sure that you have:

A Docker environment installed and configured.
A Docker Hub account.
A custom WordPress container published in a container registry.
A Kubernetes cluster running in the platform of your choice.
The kubectl command line (kubectl CLI) installed.
Helm v3.x installed.

In the next steps, remember to replace "DOCKER_USERNAME/my-custom-wordpress" with the username of your Docker account and the name of your image, respectively.

Step 1: Define Configuration Values for the Bitnami WordPress Helm Chart

To begin the process, you need to obtain the values-production.yaml file that Bitnami includes in its WordPress chart repository and edit it to use your custom image.

1) Execute the following to download the values-production.yaml file:

curl -Lo values-production.yaml https://raw.githubusercontent.com/bitnami/charts/master/upstreamed/wordpress/values-production.yaml
~~~{% endraw %}

> If your image is not stored in a public repository, you must also specify the image registry name and your registry key secret name in the "global" section of the *values-production.yaml* file. Otherwise, the cluster won't be able to pull the image from your private repository. Check the [Kubernetes official documentation](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) to learn how to create a secret for a private Docker registry.

2) Open the *values-production.yaml* and update the values below to point to your custom container image: 

* image.registry
* image.repository
* image.tag{% raw %}

~~~yaml
## Bitnami WordPress image version
## ref: https://hub.docker.com/r/bitnami/wordpress/tags/
##
image:
  registry: docker.io
  repository: DOCKER_USERNAME/my-wordpress
  tag: 1.0
~~~

3) Review the remaining parameters to make sure that you have included any other customizations that your deployment will require such as enabling Ingress rules, using external services (databases) and so on.

# Step 2: Deploy Your Custom WordPress Image on Kubernetes Using the Bitnami WordPress Helm Chart

To simplify the process of deploying the custom WordPress image, we are going to use the Bitnami's WordPress Helm chart which already has built-in support for custom Docker images.

1) Check that you can connect to your Kubernetes cluster.{% raw %}

~~~bash
kubectl cluster-info
~~~{% endraw %}

2) To make Helm pull your custom image, execute the *helm install* command followed by the modified *values-production.yaml* as follows:{% raw %} 

~~~bash
helm repo add stable https://kubernetes-charts.storage.googleapis.com/
helm install my-wordpress stable/wordpress  -f values-production.yaml
~~~{% endraw %}

![Creating pods](https://dev-to-uploads.s3.amazonaws.com/i/sh8i0d2ouvzinqcvw9l0.png)

3) Check the pod status:{% raw %}

~~~bash
kubectl get pods
~~~{% endraw %}

   You will get a list of running pods:

![Get pods](https://dev-to-uploads.s3.amazonaws.com/i/7huprl80kr1hvbxn2pb2.png)

4) To obtain the application URL, wait until the pods are running and then run the commands shown in the "Notes" section. 

5) Browse to WordPress at the resulting service IP address. You should see your WordPress site with the custom theme that you have included in your image already activated:

![Theme activated](https://dev-to-uploads.s3.amazonaws.com/i/1hgavfwnwhi4zxtt17zy.png)

6) Log in to WordPress with the credentials obtained from running the commands in the "Notes" section of the chart deployment output. Navigate to the "Plugins" section and check that the plugin is also installed and activated:

![Plugin activated](https://dev-to-uploads.s3.amazonaws.com/i/9riy0bduf4sthefael1q.png)

# Step 3: Update the Source Code and Re-Deploy the Application

As a developer you may want to introduce new implementations and features to your application. 

These are the typical steps you follow to release a new Docker image:

* Change your application source code
* Rebuild the image 
* Republish the image in your selected container registry

To complete the application update process and re-deploy your application on Kubernetes, follow these instructions:

1) Remove the installed theme in the WordPress image build in the [first guide of this series](https://dev.to/raquelcampuzano/develop-locally-a-custom-wordpress-using-a-bitnami-docker-image-44ic). 

To do so, remove all lines that refer to it both in these files: 

* *rootfs/download-extra.sh* 
* *rootfs/app-entrypoint.sh*

2) Build and republish the new image:{% raw %}

~~~bash
docker build -t DOCKER_USERNAME/my-wordpress:2.0 .
docker push DOCKER_USERNAME/my-wordpress:2.0 
~~~{% endraw %}

3) Update the Helm chart by executing the command below. It will upgrade the chart and install the latest version of your image:{% raw %}

~~~bash
helm upgrade my-wordpress stable/wordpress \
-f values-production.yaml \
--set image.tag=2.0
--set wordpressPassword="$(kubectl get secret my-wordpress-wordpress -o jsonpath='{.data.wordpress-password}' | base64 --decode)" \
--set mariadb.db.password="$(kubectl get secret my-wordpress-mariadb -o jsonpath='{.data.mariadb-password}' | base64 --decode)"
~~~{% endraw %}

4) Browse again to the application IP address. You should see your WordPress site with the default theme enabled.

![WordPress default theme](https://dev-to-uploads.s3.amazonaws.com/i/qnlqpb3mwonvmlid5vuq.png)

It is not magic! It is the power of Helm.

You have not only deployed your custom WordPress in a production environment but also applied a change in the application code and re-deployed your website with the updated configuration.

Develop Locally A Custom WordPress Using A Bitnami Docker Image

Raquel Campuzano Godoy — Wed, 29 Jan 2020 15:22:12 +0000

Originally published at docs.bitnami.com.

Why WordPress and Why Containers for Local Development?

When you are searching for an open-source CMS to create your blog or website, chances are that you finally chose WordPress.

WordPress is easy to use and includes a lot of plugins and themes enabled by default so you can run your website in a matter of minutes.

The best way to start developing locally is to use containers. They offer many of the same advantages as developing in VMs, but with lower overhead in terms of developer effort and development machine resources.

Bitnami containers are a great resource for local development: they allow you to save a lot of time in coding and ensure that you launch always the latest and secure application image.

As a developer, you may probably want to add some customizations to the default configuration that Bitnami delivers in its containers. This tutorial shows how to add and activate both a custom plugin and a theme for the first run.

Set Up Prerequisites

Before starting, make sure that you have already set up the following:

A Docker environment installed and configured.
A Docker Hub account.

Step 1: Create a Script To Add a Plugin and a Theme

To begin the process, you need to obtain the Bitnami Docker image for WordPress.

1) Clone the Bitnami Docker WordPress repository and change to the directory that contains all files:



git clone https://github.com/bitnami/bitnami-docker-wordpress.git
cd bitnami-docker-wordpress

The next step is to create a script to specify which are the plugins/themes you want to install in your WordPress. This script will contain the instructions to download and uncompress the plugin and the theme files as well as the path where they should be installed (/opt/bitnami/wordpress/wp-content/).

2) In the rootfs/ directory, create a file named download-extra.sh with the following content:



#!/bin/bash
curl -o /tmp/bbpress2.5.14.zip https://downloads.wordpress.org/plugin/bbpress.2.5.14.zip
curl -o /tmp/gambit.1.5.3.zip https://downloads.wordpress.org/theme/gambit.1.5.3.zip
unzip /tmp/bbpress.2.5.14.zip -d /opt/bitnami/wordpress/wp-content/plugins
unzip /tmp/gambit.1.5.3.zip -d /opt/bitnami/wordpress/wp-content/themes

Step 2: Edit the Dockerfile To Add the Custom Script

To install the plugins and themes you have selected in the first run, it is necessary to indicate in the Dockerfile where are the instructions to perform that action.

1) Open the Dockerfile (5/debian-9/Dockerfile) and add the unzip packages to the RUN install_packages command list:



# Install required system packages and dependencies
RUN install_packages unzip libbz2-1.0 libc6 libcomerr2 libcurl3 libexpat1 libffi6 libfreetype6 libgcc1 libgcrypt20 libgmp10 libgnutls30 libgpg-error0 libgssapi-krb5-2 libhogweed4 libicu57 libidn11 libidn2-0 libjpeg62-turbo libk5crypto3 libkeyutils1 libkrb5-3 libkrb5support0 libldap-2.4-2 liblzma5 libmemcached11 libmemcachedutil2 libncurses5 libnettle6 libnghttp2-14 libp11-kit0 libpcre3 libpng16-16 libpq5 libpsl5 libreadline7 librtmp1 libsasl2-2 libsqlite3-0 libssh2-1 libssl1.0.2 libssl1.1 libstdc++6 libsybdb5 libtasn1-6 libtidy5 libtinfo5 libunistring0 libxml2 libxslt1.1 libzip4 zlib1g

2) Add the RUN bash download-extra.sh command under the COPY rootfs/ line:



COPY rootfs /
RUN bash download-extra.sh

Step 3: Activate the Plugin and Theme at Initialization Time

To initialize the container with the installed plugin and theme already activated, it is necessary to add this action in the application entrypoint script.

1) Open the app-entrypoint.sh (5/debian-9/rootfs/app-entrypoint.sh) file and add the following:



nami_initialize apache php mysql-client wordpress
su daemon -s /bin/bash -c '/opt/bitnami/wp-cli/bin/wp plugin activate bbpress'
su daemon -s /bin/bash -c '/opt/bitnami/wp-cli/bin/wp theme activate gambit'
info "Starting wordpress... "

Step 4: Edit the docker-compose.yml File To Point To Your Image

By default, the docker-compose.yml file is pointing to the latest version of the WordPress Docker image packaged by Bitnami. To point to your custom image, it is necessary to change that value in the docker-compose.yml.

In the next steps, remember to replace "DOCKER_USERNAME/my-custom-wordpress" with the username of your Docker account and the name of your image, respectively.



wordpress:
   image: 'DOCKER_USERNAME/my-custom-wordpress:latest'

Step 5: Build the Docker Image

Let's build the Docker image.

1) Execute the docker build command within the directory that contains the Dockerfile (5/debian-9/):



cd 5/debian-9/
docker build -t DOCKER_USERNAME/my-custom-wordpress:latest .

2) Check that the image has been added to the local repository by executing:



docker images | grep my-custom-wordpress

Step 6: Test the Docker Image and Access Locally To Your Custom Application

To test locally your custom image, it is necessary to run the container.

1) Execute the docker-compose up command:



docker-compose up

If everything went well, you should see an output message similar to this:

2) Enter http://localhost in your web browser and check that the theme is already activated:

3) Log in to the WordPress admin panel using the default credentials: username user and password bitnami.

Navigate to the "Plugins" section. You will see the BBplugin already installed and activated:

Step 7: Publish the Docker Image

Now that your Docker image is built and contains your application code, you can upload it into a public registry. This guide uses Docker Hub, but you can select one of your own choice such as:

1) Log in to Docker Hub



docker login

2) Push the image to your Docker Hub account:



docker push DOCKER_USERNAME/my-custom-app:latest

Congratulations! You have customized a WordPress Docker image, tested and built it, and now it is available in Docker Hub and ready to be deployed in a production scenario!

Next Steps

Deploy a Custom WordPress Image on a Kubernetes Cluster Using Bitnami Helm Charts