{"id":36100,"date":"2016-06-23T16:30:58","date_gmt":"2016-06-23T11:00:58","guid":{"rendered":"http:\/\/www.tothenew.com\/blog\/?p=36100"},"modified":"2016-06-24T11:14:06","modified_gmt":"2016-06-24T05:44:06","slug":"using-docker-compose-to-migrate-wordpress-website-on-docker","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/using-docker-compose-to-migrate-wordpress-website-on-docker\/","title":{"rendered":"Using Docker Compose to Migrate WordPress Website on Docker"},"content":{"rendered":"

\"03.docker-wordpress\"<\/span><\/p>\n

Docker is a like your mini virtual machine that is very light on your host resources. Unlike virtual machines, which need their own kernel, Docker creates virtualized experience<\/a> on top of your running kernel. The mini virtual machines provided by Docker are called “containers”. These containers are platform independent and can be reused for deploying applications on different environments.<\/span><\/p>\n

In this blog post, we will migrate an existing WordPress website on Docker. We will use Nginx as the web server (with php5-fpm for PHP support) and MySQL as the database solution. We will create 2 images (for Nginx and MySQL) and use Docker Compose to link them.<\/span><\/p>\n

The steps followed assume that the Docker server<\/span> is a separate machine from the current WordPress server. However, both of these can be the same machine in which case you do not need to transfer the files to the other machine. This setup can be used by developers<\/a> as well for running the WordPress website on their own machine.<\/span><\/p>\n

Prerequisites:<\/strong><\/span><\/h2>\n

This blog post assumes that the target machine is running Linux based OS with Docker and Docker Compose installed. Below are the requirements for this setup:<\/span><\/p>\n

    \n
  • Operating System: Any Linux machine (Ubuntu 14.04 server is used for this demo)<\/span><\/li>\n
  • Docker version 1.11.2<\/span><\/li>\n
  • Docker Compose version 1.7.1<\/span><\/li>\n<\/ul>\n

    So let’s start. Below are the steps you need to follow.<\/span><\/p>\n

    STEPS:<\/span><\/h2>\n

    1. Backup website files and database.<\/strong><\/span><\/h3>\n

    Before starting with the migration, we need to take backup of website files used by WordPress and the database used by WordPress. Let’s start by backing up the DocumentRoot for WordPress website:<\/span><\/p>\n

    root@ubuntu-wp-server:~# tar -czf wordpressback.tgz wordpress\/<\/span><\/pre>\n
    Now let’s dump the WordPress database.<\/span><\/p>\n
    root@ubuntu-wp-server:~# mysqldump -u root -p wordpress | gzip > wordpress.sql.gz\r\nEnter password:<\/span><\/pre>\n
    Enter your MySQL password when prompted. We have compressed the database dump so that the transfer is faster.<\/span><\/p>\n
    Note: We assume that there are no write queries on the database in this migration process. This migration can be achieved with zero downtime with proper strategy.<\/span><\/p>\n
    root@ubuntu-wp-server:~# gzip wordpress.sql<\/span><\/pre>\n
    2. Setup new DocumentRoot and DB for Docker containers<\/strong><\/span><\/h3>\n
    Now let’s transfer these files onto the Docker server. You can also use your own machine for Docker. In that case, you do not need to transfer the files.<\/span><\/p>\n
    root@ubuntu-wp-server:~# scp wordpressback.tgz wordpress.sql.gz \\\r\n> wp-docker.com:\/docker-data\/wordpress\/\r\nroot@wp-docker.com's password:\r\nwordpressback.tgz 100% 7589KB 7.4MB\/s 00:00\r\nwordpress.sql.gz 100% 90KB 89.6KB\/s 00:00<\/span><\/pre>\n
    We are using these 2 Docker images:<\/span><\/p>\n
      \n
    1. wpmysql<\/em><\/span><\/li>\n
    2. wpnginx<\/em><\/span><\/li>\n<\/ol>\n
      Note:<\/strong> These images can be pulled from Docker Hub<\/span> with following commands:<\/span><\/p>\n
      docker pull raghuttnd\/ttnblog_wpmysql\r\ndocker pull raghuttnd\/ttnblog_wpnginx<\/span><\/pre>\n
      We will shortly have a look at the Dockerfiles used to create these 2 images and the Docker Compose files that we have used to bring up these containers.<\/span><\/p>\n
      Now that the dump file and the website tar is transferred on the Docker server, we need to extract the files and prepare the DocumentRoot directory which wpnginx<\/em><\/span> container will use.<\/span><\/p>\n
      The directory “\/docker-data\/wordpress”<\/em> will be used as the DocumentRoot for our website to be hosted on Docker. We will mount this directory inside the Docker container.<\/span><\/p>\n
      root@ubuntu-docker:~# cd \/docker-data\/wordpress\/\r\nroot@ubuntu-docker:\/docker-data\/wordpress# tar -xzf wordpressback.tgz --strip 1\r\nroot@ubuntu-docker:\/docker-data\/wordpress# rm wordpressback.tgz<\/span><\/pre>\n
      The DB dump file needs to be in a separate directory. We will use the directory “\/docker-data\/dbdump\/”<\/em> for keeping this file and mount this directory inside the wpmysql<\/em><\/span> container.<\/span><\/p>\n
      root@ubuntu-docker:~\/docker\/compose\/wordpress# mv wordpress.sql.gz \/docker-data\/dbdump\/\r\nroot@ubuntu-docker:~\/docker\/compose\/wordpress# gunzip \/docker-data\/dbdump\/wordpress.sql.gz<\/span><\/pre>\n
      Here, we need to make changes in the wp-config.php file according to our new setup. We need DB name, DB User, DB Password and DB Host. These will be created in our wpmysql<\/em><\/span> container. So once our Docker Compose file is ready, we will come back and make these changes.<\/span><\/p>\n
      3.\u00a0Docker Setup<\/strong><\/span><\/h3>\n
      The Docker setup involves setting up the images using the Dockerfiles and Entrypoint scripts (launch scripts).<\/span>
      \nNow we need to bring up the Docker containers. The containers used for this demo are based on ubuntu:14.04 image.<\/span><\/p>\n
      wpnginx:<\/strong><\/span>
      \nThe image used for Nginx is created using this Dockerfile:<\/span><\/p>\n
      [sourcecode language=”bash”]FROM ubuntu:14.04
      \nRUN apt-get update<\/p>\n
      #Install nginx
      \nRUN apt-get -y install \\
      \nnginx \\
      \nphp5-fpm \\
      \nphp5-mysql \\
      \nwget
      \n#Clear the DocumentRoot
      \nRUN rm -rf \/usr\/share\/nginx\/html\/*
      \n#Copy the default configuration
      \nCOPY conf\/default \/etc\/nginx\/sites-available\/
      \nRUN mkdir \/root\/scripts
      \nCOPY launch.sh \/root\/scripts\/
      \nENTRYPOINT \/bin\/bash \/root\/scripts\/launch.sh[\/sourcecode]<\/p>\n
      The launch script starts Nginx and php5-fpm in background and continues running:<\/span><\/p>\n
      [sourcecode language=”bash”]#!\/bin\/bash
      \nservice nginx start
      \nservice php5-fpm start
      \ntail -f \/var\/log\/nginx\/{access.log,error.log}[\/sourcecode]<\/p>\n
      You can see the Nginx logs with the command:<\/span><\/p>\n
      # docker logs -f wpnginx-container<\/span><\/pre>\n
      wpmysql:<\/strong><\/span>
      \nThe Dockerfile used for this image is:<\/span><\/p>\n
      [sourcecode language=”bash”]FROM ubuntu:14.04
      \nRUN apt-get update<\/p>\n
      #Install mysql non-interactive
      \nRUN echo mysql-server mysql-server\/root_password password mysqlpass | debconf-set-selections
      \nRUN echo mysql-server mysql-server\/root_password_again password mysqlpass | debconf-set-selections
      \nRUN apt-get -y install mysql-server
      \nRUN sed -i ‘\/bind-address\/c\\bind-address\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = 0.0.0.0’ \/etc\/mysql\/my.cnf
      \nRUN mkdir \/root\/scripts
      \nCOPY launch.sh \/root\/scripts\/
      \nRUN touch \/var\/lib\/mysql\/firstrun
      \nRUN ln -s \/var\/lib\/mysql\/local.cnf \/root\/.my.cnf<\/p>\n
      ENTRYPOINT \/bin\/bash \/root\/scripts\/launch.sh[\/sourcecode]<\/p>\n
      The default root password used in this image is overridden when the image is brought up the first time (using the launch script).<\/span><\/p>\n
      Here, as you can see that the ENTRYPOINT for this image is a launch script. This launch script does the following (using environment variables):<\/span><\/p>\n
        \n
      1. Creates the root password for the first time.<\/span><\/li>\n
      2. Creates the WordPress database.<\/span><\/li>\n
      3. Creates the WordPress user and sets its password.<\/span><\/li>\n
      4. Optionally populate the above database using the dump file if the dump file is provided in the environment variable \u201cWORDPRESS_DUMP_FILE\u201d (and removes the dump file if the dump is successful).<\/span><\/li>\n<\/ol>\n
        Here comes the launch script for wpmysql<\/em>:<\/span><\/p>\n
        [sourcecode language=”bash”]
        \n#!\/bin\/bash<\/p>\n
        FIRSTRUN="\/var\/lib\/mysql\/firstrun"
        \nWORKDIR="\/dockerinit\/"
        \nMYSQLCRED="\/root\/.my.cnf"
        \nmkdir -p $WORKDIR<\/p>\n
        if [ -e $FIRSTRUN ]
        \nthen
        \n\tif [ -z $MYSQL_ROOT_PASSWORD ]
        \n\tthen
        \n\t\techo >&2 "You are running the script for first time."
        \n\t\techo >&2 "Please specify MYSQL_ROOT_PASSWORD environment variable."
        \n\t\texit 1
        \n\telse
        \n\t\tservice mysql start
        \n\t\techo "Resetting root password for first time."
        \n\t\tmysql -u root -pmysqlpass <<-EOSQL
        \n\t\t\tDELETE FROM mysql.user WHERE User=’root’ ;
        \n\t\t\tCREATE USER ‘root’@’%’ IDENTIFIED BY ‘${MYSQL_ROOT_PASSWORD}’ ;
        \n\t\t\tGRANT ALL ON *.* TO ‘root’@’%’ WITH GRANT OPTION ;
        \n\t\t\tDROP DATABASE IF EXISTS test ;
        \n\t\t\tFLUSH PRIVILEGES ;
        \n\t\tEOSQL
        \n\t\t>$MYSQLCRED
        \n\t\techo "[client]" >> $MYSQLCRED
        \n\t\techo "user=root" >> $MYSQLCRED
        \n\t\techo "password=${MYSQL_ROOT_PASSWORD}" >> $MYSQLCRED
        \n\t\trm $FIRSTRUN
        \n\tfi
        \nfi<\/p>\n
        #Setting passed env variables
        \nWORDPRESS_DB_USER=${ENV_WORDPRESS_DB_USER:=wpuser}
        \nWORDPRESS_DB_PASSWORD=${ENV_WORDPRESS_DB_PASSWORD:=wppass}
        \nWORDPRESS_DB_NAME=${ENV_WORDPRESS_DB_NAME:=wordpress}<\/p>\n
        service mysql start<\/p>\n
        echo "Initializing database.."
        \nmysql <<-EOSQL
        \n\tCREATE DATABASE IF NOT EXISTS $WORDPRESS_DB_NAME ;
        \n\tGRANT ALL ON $WORDPRESS_DB_NAME.* TO ‘$WORDPRESS_DB_USER’@’%’ IDENTIFIED BY ‘$WORDPRESS_DB_PASSWORD’ ;
        \n\tFLUSH PRIVILEGES ;
        \n\tEOSQL<\/p>\n
        #Checking if there is any file for restoring the DB dump
        \nif [[ -n $WORDPRESS_DUMP_FILE ]]
        \nthen
        \n\tif [[ -f $WORDPRESS_DUMP_FILE ]]
        \n\tthen
        \n\t\techo "Checking if there is any file for restoring the DB dump"
        \n\t\tmysql -u ${WORDPRESS_DB_USER} -p${WORDPRESS_DB_PASSWORD} $WORDPRESS_DB_NAME < $WORDPRESS_DUMP_FILE
        \n\t\tif [[ $? -eq 0 ]]
        \n\t\tthen
        \n\t\t  rm -f $WORDPRESS_DUMP_FILE #So that we dont accidentally dump again
        \n\t\tfi
        \n\telse
        \n\t\techo >&2 "The dump file specified in variable WORDPRESS_DUMP_FILE does not exist."
        \n\t\texit 2
        \n\tfi
        \nfi<\/p>\n
        service mysql stop
        \n\/usr\/bin\/mysqld_safe<\/p>\n
        [\/sourcecode]<\/p>\n
        Before bringing up the Nginx container, we need to make sure that MySQL container is running. So we will use Docker Compose for solving this dependency issue. The docker-compose.yml file to be used is:<\/span><\/p>\n
        [sourcecode language=”bash”]version: ‘2’
        \nservices:
        \nnginx-wordpress:
        \nimage: wpnginx
        \nhostname: wphost
        \ncontainer_name: wpnginx-container
        \nvolumes:
        \n– "\/docker-data\/wordpress\/:\/usr\/share\/nginx\/html\/"
        \nports:
        \n– 80:80
        \ndepends_on:
        \n– mysql-wordpress<\/p>\n
        mysql-wordpress:
        \nimage: wpmysql
        \nhostname: wpmysqlhost
        \ncontainer_name: wpmysql-container
        \nvolumes:
        \n– \/docker-data\/dbdump\/:\/dbdump
        \n– wp-mysql-data:\/var\/lib\/mysql
        \nenvironment:
        \n– MYSQL_ROOT_PASSWORD=ttndpass
        \n– ENV_WORDPRESS_DB_USER=wpuser
        \n– ENV_WORDPRESS_DB_PASSWORD=wppass
        \n– ENV_WORDPRESS_DB_DATABASE=wordpress
        \n– WORDPRESS_DUMP_FILE=\/dbdump\/wordpress.sql<\/p>\n
        volumes:
        \nwp-mysql-data:[\/sourcecode]<\/p>\n
        In this file, we have passed few environment variables to MySQL image. Below are the variables used:<\/span><\/p>\n
          \n
        • MYSQL_ROOT_PASSWORD – Password for MySQL <\/span>root user.<\/span><\/li>\n
        • ENV_WORDPRESS_DB_USER – The new WordPress username.
          \n<\/span><\/li>\n
        • ENV_WORDPRESS_DB_PASSWORD – Password <\/span>for above WordPress<\/span> user.<\/span><\/li>\n
        • ENV_WORDPRESS_DB_DATABASE – Database name to be used by WordPress.<\/span><\/li>\n
        • WORDPRESS_DUMP_FILE – Path to the dump file which needs to be restored to above database.<\/span><\/li>\n<\/ul>\n
          One last step before bringing up the Docker containers: We need to make DB connection changes in the wp-config.php file. The DB host in this file will be the name of MySQL service defined in the Compose file above (mysql-wordpress)<\/span>.<\/span><\/p>\n
          4. Bring up the Containers:<\/strong><\/span><\/h3>\n
          Now let\u2019s bring up the containers using Docker Compose. The following command can be executed to run the containers in background:<\/span><\/p>\n
          root@ubuntu-docker:~\/docker\/compose\/wordpress# docker-compose up -d\r\nCreating wpmysql-container\r\nCreating wpnginx-container<\/span><\/pre>\n
          That’s all folks.<\/span><\/p>\n
          It might seem like a lot but once the ground work is done (the Dockerfile and docker-compose.yml), there is not much left to take care of. If you just want to use these images, without going into the whole process of creating them, you can pull them from Docker Hub a<\/span>s mentioned earlier.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
          Docker is a like your mini virtual machine that is very light on your host resources. Unlike virtual machines, which need their own kernel, Docker creates virtualized experience on top of your running kernel. The mini virtual machines provided by Docker are called “containers”. These containers are platform independent and can be reused for deploying […]<\/p>\n","protected":false},"author":931,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":27},"categories":[2348],"tags":[2590,2558,3592,3593,3594,3596,3595],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/36100"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/931"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=36100"}],"version-history":[{"count":0,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/36100\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=36100"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=36100"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=36100"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}