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.

• Verified Publisher. Official Images Official Images published by Docker. Application Frameworks. Application Infrastructure. Application Services.
• 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.
• I created a WordPress development instance using the official Docker image for WordPress in Docker Hub. In some cases, you want to see the log of errors and do not activate the debug mode in WordPress. In example, a plugin can generate warnings that make difficult to debug and that could break responses for Ajax requests in your site.
• TL;DR – create the directory wordpress in the container’s web root and add -w='/var/www/html/wordpress' to the docker run (or create) command. This sets the current working directory for docker-entrypoint.sh to work in, and it will install the wp-. and.htaccess files there.

Wordpress On Docker

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:

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

Additionally, the wordpress Dockerfile has an example of doing this. The following Docker Hub features can help with the task of keeping your dependent images up-to-date: Automated Builds let Docker Hub automatically build your Dockerfile each time you push changes to it. Include pre-installed themes / plugins.

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:

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

About Dockerfiles

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.

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.

Docker Hub Dockerfile Wordpress

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.”

Docker Hub Wordpress Alpine

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.

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

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

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

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