Docker Hub Wordpress



WordPress is a free and open source blogging tool and a content management system (CMS) based on PHP and MySQL, which runs on a web hosting service. Features include a plugin architecture and a template system. WordPress is used by more than 22.0% of the top 10 million websites as of August 2013. WordPress is the most popular blogging system in use on the Web, at more than 60 million websites. View Quentin Birgaentzle’s profile on LinkedIn, the world’s largest professional community. Quentin has 5 jobs listed on their profile. See the complete profile on LinkedIn and discover Quentin’s connections and jobs at similar companies. Create a single Docker Compose file to dowload wordpress docker image and mysql docker image to create respective docker containers. Run your wodpress site from the container locally. You can migrate this container back to a new EC2 and host your site via a container — This is not part of this post, but will be part of my next post. Testing Docker Installation: Docker is now installed on the system, lets run the first container to test the docker installation using docker official image “Hello-World”. You can refer the complete documentation of this image here. Pulling the image of ‘hello-word‘ from docker hub. Create a directory for the Dockerfile that will create a custom WordPress image. $ mkdir /Documents/docker/dockerfiles/wordpress; Navigate into that directory and create a file called dockerfile. As with Docker Compose, projects, which always uses the file name docker-compose.yml, Dockerfiles are always named dockerfile.

Wordpress

This is part four of five in my Use Docker to create a local WordPress development environmenttutorial.

About Dockerfiles

Docker Hub Php Wordpress

Dockerfiles are text files that provide instructions to Docker on how to start with an existing image and build a new, customized image through a series of instructions. I was aware of Dockerfiles from my introduction to Docker on LinkedIn Learning. I did not think I would need them for a basic WordPress environment. But I wanted to learn more about them, and thought that I could use Dockerfiles to create customized WordPress and phpMyAdmin images to use with Docker Compose. That way I could avoid manually customizing the container the way I did in WordPress and Docker: Customize a Docker container.

I looked around and found this Dockerfile tutorial by Mark Takacs, which had a long video that I found very informative and enlightening. I looked around to see if anybody else were using Dockerfiles for something similar and found this tutorial on DaveScripts.com that included a php.ini file being copied with a Dockerfile.

Create a Dockerfile for customizing a WordPress image

  1. Earlier we created a directory just for our Docker projects. Navigate into that directory.
    $ cd ~/Documents/docker
  2. Create a new directory to store your Dockerfiles:
    $ mkdir dockerfiles
  3. Create a directory for the Dockerfile that will create a custom WordPress image.
    $ mkdir ~/Documents/docker/dockerfiles/wordpress
  4. Navigate into that directory and create a file called dockerfile. As with Docker Compose, projects, which always uses the file name docker-compose.yml, Dockerfiles are always named dockerfile.
    $ cd docker/dockerfiles/wordpress && touch dockerfile
  5. Open this link to my Dockerfile for WordPress on GitHub, select all of the text, and copy it.
  6. Open the dockerfile you created with your text editor and paste the text from my Dockerfile into it.
  7. Make any changes to file names or file paths that are needed and save your dockerfile.

What’s in this Dockerfile?

Some of the syntax here looks like standard Linux commands or what you might see in a Bash script. What makes Dockerfiles different are instructions, of which there are several. However, I am only using a few simple ones here. Every Dockerfile must start with the FROM instruction: what is the base image? In my case, I am using the official WordPress image from Docker Hub (wordpress:latest), but you can use an image from a different registry, such as a registry you manage yourself.

Wordpress Docker Github

After we get the base image I use the RUN instruction to run a series of commands, just as if it were a Bash script. In this example, I RUN commands to do an apt update and upgrade, install Vim, install wget, and install the MariaDB Client that is needed for the WP-CLI tool. These are some of the same commands I used in the previous article, but now I get Docker to make those customizations when it builds my image.

Then I use another RUN instruction again to install WP-CLI just as I did manually in the previous article. I also use this instruction to clean up the /usr/local/etc/php directory by removing php.ini-development and php.ini-production.

Next there is a COPY instruction. Not unlike the cp command, this COPY looks for a php.ini file in the directory where the Dockerfile is located and copies it to /usr/local/etc/php inside of the container.

One final point: I created the php.ini file by going into the WordPress container I customized in the previous article, copied its contents, and saved it locally as php.ini. This way, I know that it is the php.ini file that ships with the WordPress image, but that includes my changes to parameters like upload_max_filesize.

Include the PHP.ini file

The COPY instruction is going to look for the php.ini file in the same directory as your Dockerfile, so let’s add it.

  1. From within the wordpress directory with your Dockerfile, create php.ini:
    touch php.ini
  2. Open this link to the PHP.ini file I included for WordPress on my GitHub, select all of the text, and copy it.
  3. Open the php.ini file you created with your text editor and paste the text into it.
  4. Save php.ini.

Build the image with docker build

Dockerfiles build Docker images. To test my Dockerfile, I use the docker build command. I included the command on line 2 of my Dockerfile (it’s commented out).

  • docker build: Build a Docker image.
  • -t: Tag the image with the name:tag format. In this case the name is wp_custom_image and the tag is local_0-1. The name and tag values I used are just for demonstration, so feel free to use whatever naming convention you like.
  • . : This trailing dot is very important. This represents the path to your Dockerfile. In this case, since we are in the same directory as our Dockerfile, that path is represented with . .

There will be a lot of output. Look for the “steps.” Each step is an instruction from the Dockerfile. Starting with FROM, Docker is running a container for each step, making the changes like installing packages. After it completes an instruction, Docker commits that container as an image before creating the final image.

You can see the hash values for each container as well as the term “intermediate container.”

When the final instruction is completed, Successfully built and a hash value for the Image ID displays.

Use docker images to list your locally stored images. You can identify the customized WordPress image using the REPOSITORY, TAG, and IMAGE ID values.

Create a Dockerfile for customizing a phpMyAdmin image and build it

Now that we’ve created our first image from a Dockerfile, let’s create another that integrates the PHP configuration changes into the phpMyAdmin image.

Docker Hub Wordpress Bitnami

  1. From within the dockerfiles directory you created earlier, create a phpmyadmin directory.
    $ mkdir ~/Documents/docker/dockerfiles/phpmyadmin
  2. Navigate into that directory and create a file called dockerfile.
    $ cd docker/dockerfiles/phpmyadmin && touch dockerfile
  3. Open this link to my phpMyAdmin Dockerfile for WordPress on GitHub, select all of the text, and copy it.
  4. Open the dockerfile you created with your text editor and paste the text from my Dockerfile into it.
  5. Make any changes to file names or file paths that are needed and save your dockerfile.
  6. From within the phpmyadmin directory with your Dockerfile, create php.ini:
    $ touch php.ini
  7. Open this link to the PHP.ini file I included for phpMyAdmin on my GitHub, select all of the text, and copy it.
  8. Open the php.ini file you created with your text editor and paste the text into it.
  9. Save php.ini.
  10. From within the phpmyadmin directory, run the docker build command:
    $ docker build -t phpmyadmin_local:phpmyadmin_custom_1.0 .
  11. Watch the steps and all of the output and look for the final Successfully built message.
  12. Use docker images to list your images and look for the new image you have created.

Use your own image with your Docker Compose project

Now we have created our own image, we can include that with our Docker Compose project.

Open your docker-compose.yml file. Look for the image: key under wp (the WordPress container) and phpmyadmin (the phpMyAdmin container). The existing version of docker-compose.yml had the value of wordpress:latest (for WordPress) and phpmyadmin/phmyadmin:latest (for phpMyAdmin). These are the images that your local machine will pull from Docker Hub. But we can replace the values for image: with the names of the images we built from our Dockerfiles:

  • wordpress_local:wp_custom_1.0
  • phpmyadmin_local:phpmyadmin_custom_1.0

Docker Hub Drupal

Here’s what that looks like in the docker-compose.yml file:

The next time you run docker-compose up -d, your Docker application will be created with the images that you built with your Dockerfiles.

Docker Hub Dockerfile Wordpress

Up next, a conclusion: WordPress and Docker: Putting it all together.

One of docker function is communication with registry directly related with cloud computing. You also need to change your local images into specific name which one do you want. You should be register your docker hub account in here.

Now, after you register your docker hub, you should be pull a docker image from registry. After you finished, you change tag of docker image to your docker hub account. This case can you see on command below:

After that, you can see in docker images like this:

How To Install Wordpress Docker

Then, you should be login into your docker hub account to push your local images by using command: docker login.

Finally, you can push your local images to you docker hub account by using command: docker push afauzanaqil/ubuntu:latest.

Well, you finished upload your local images to your docker hub account. Now, you have to pull it again in different terminal.

You should be check your docker images with running your docker using your docker images. The command that case on below: