In the previous post, we saw some tips to improve your WordPress development workflow. To get clearer, let’s go to practice, showing some tools that can help you in each of the environments mentioned in the previous post.

The local development environment

Our first step is to set up the local development environment. You can configure PHP, MySQL, and Apache on your computer or go for more practical alternatives such as Vagrant or MAMP. I recommend Vagrant because of practicalities, and because it runs in a virtual machine. In addition, you can back up a configured environment and put it on another computer whenever you need, using the same settings.

We have a post addressing the configuration of the Vagrant development environment.

You can also easily find tutorials on the Internet explaining the installation/configuration of Vagrant / MAMP, or explaining how to configure Apache, MySQL, and PHP on your computer. I will use Ubuntu 14.04 LTS in the following examples, so if you use OS X or any other operating system, some commands may vary. We did not test these tools in Windows.

To assist us in managing our local project, we installed WP-CLI, a command line assistant for WordPress. With it, we were able to do several WordPress operations per command line, such as downloading, installing, configuring, creating and removing the database.

Installing and configuring WP-CLI

There are two ways to download WP-CLI from the terminal:

Curl: curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar

Wget: wget https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar

After downloading, we can test if everything is ok with the downloaded files:

php wp-cli.phar –info

If all is right, let’s extract the file in the bin folder, and create the wp command to do the operations:

chmod +x wp-cli.phar

sudo mv wp-cli.phar /usr/local/bin/wp

Turn the command wp –info and see if the wp command is working.

Downloading WordPress with WP-CLI

Create a directory for your project in the local development environment. Enter this directory from the terminal and run the following command (make sure you have given permission to write to this directory):

wp core download –locale= nl_NL

The above command will download WordPress in the directory we created. Now let’s configure WordPress:

wp core config –dbname=database –dbuser=mysql_user –dbpass=mysql_password

The above command generates the file wp-config.php. Do not forget to replace the values database, mysql_userand mysql_password. With our file configured, we can run the following command:

wp db create

With this command, we are creating the database, with the information that we defined in wp-config.php with the previous command. Finally, we passed the final configurations and installed our project:

wp core install --url="url_local" --title="My website Title" --admin_user="username" --admin_password="password" --admin_email="email"

With just these four commands, we have WordPress installed and configured in our local environment. Now open your browser at the address of your local project. If all went well, you’ll see a default installation of WordPress.

Version control

Now that we have our local project installed and configured, let’s set up version control. First, we must create a repository on GitHub. Then we need to add the remote address of our project. After creating the repository, open the terminal, enter the project directory and enter the following commands:

git init
git remote add origin remote-repository-address

Now our project already has version control. After each change, if you type git status, you can see the files that have been modified. If you want to see exactly which snippets of the files have been modified, you can type git diff. To send the changes to GitHub, do the following:

git add.
git commit -m "Description of changes"
git push origin master

There are several other things we can do using Git, but initially, these commands will serve us.

Staging – the type approval environment

So far we’ve set up our local development environment and our repository on GitHub. With each change in the project, we send the files to GitHub. Only with this, we are already allowing revision of code and allowing errors to be reversed. The next step is to set up our homologation environment.

We support Git and we can set up a staging and production environment. This helps a lot in productivity and organization since we can deploy using Git.

You can add the remote repository to your local environment as follows:

git remote add staging git@git.wpengine.com:staging/meu-site.git

You should have noticed that this command is the same as the one we used to add the GitHub remote repository. What changes is the domain, which instead of GitHub is WP Engine, and the name of project. WP Engine creates the repositories for you on the server itself. Once this is done, you can deploy staging as follows:

git push staging master

If you want to opt for cheaper alternatives and use traditional servers that do not have Git support, you can deploy your project using Wordmove.

Wordmove

Wordmove is a Rubygem that allows us to deploy our WordPress project in several different environments. In our case, we can use it to deploy in the approval and production environments. How to transfer files is done via SSH, we need some services installed on our computer: rsync, sshpass and openssh. To install them type the following commands:

sudo apt-get update
sudo apt-get install rsync
sudo apt-get install sshpass
sudo apt-get install openssh
sudo apt-get install openssh-server

With these dependencies installed, we can already install wordmove:

gem install wordmove

In the main directory of your local project (same folder as wp-config.php ), create a file called Movefile, with the following content:

# ambiente local
local:
  vhost: "https://vhost.local" # Url from your local environment
  wordpress_path: "/home/username/sites/seu-site" # Absolute path of your project
  database:
    name: "database_name" # Local database
    user: "user" # User database
    password: "password" # Database password
    host: "127.0.0.1" # Database host
# Approval environment
staging:
  vhost: "https://example.com"
  wordpress_path: "/var/www/seu-site"
  database:
    name: "database_name"
    user: "user"
    password: "password"
    host: "host"
  exclude:
    - ".git/"
    - ".gitignore"
    - ".sass-cache/"
    - "bin/"
    - "tmp/*"
    - "Gemfile*"
    - "Movefile"
    - "wp-config.php"
    - "wp-content/*.sql"
  ssh:
    host: "host"
    user: "user"
    password: "password" # The password is optional, you can use SSH keys, if you prefer
# Production environment
production:
  vhost: "https://example.com"
  wordpress_path: "/var/www/seu-site"
  database:
    name: "database_name"
    user: "user"
    password: "password"
    host: "host"
  exclude:
    - ".git/"
    - ".gitignore"
    - ".sass-cache/"
    - "bin/"
    - "tmp/*"
    - "Gemfile*"
    - "Movefile"
    - "wp-config.php"
    - "wp-content/*.sql"
  ssh:
    host: "host"
    user: "user"
    password: "password" # The password is optional, you can use SSH keys, if you prefer

This file is written in YAML, and quite self-explanatory. If you would like to learn more about wordmove, you can visit the official project repository: https://github.com/welaika/wordmove

The Wordmove configuration file is divided into major sections, which are our environments: local, staging and production. Each of the environments has its specific settings, but in general, we have these options:

Vhost

  • Is the URL of our project

WordPress_path

  • The absolute path of our project

database

  • Access credentials to our database

Exclude

  • Files that you do not want to send to the environment in question (we do not need to send wp-config.php to the server for example)

SSH

  • Credentials of access to the environment in question via SSH

These settings already allow us to deploy our project in the approval and production environments.

Deploy with Wordmove

You already know how the development process works so far. First, we developed in the local environment, we uploaded the changes to GitHub and then we went up to the staging environment. We show above that you can deploy staging on some servers using GIT (as in the case of WP Engine). But if you have chosen traditional servers and are using Wordmove, you can upload the project to the approval environment as follows:

wordmove push -e staging –all

The above command will raise our entire project to staging, including the database, so be careful. If we want to upload only the theme we are working on, we can do the following:

wordmove push -e staging -t

The same goes for the plugins:

wordmove push -e staging -p

To “copy” the entire project from our certification environment to the local environment:

wordmove pull -e staging –all

The use of Wordmove is very simple, for more information you can consult the documentation, or type wordmove helping the terminal.

Production environment

So far we have seen how to configure our local environment, we have already created the repository of our project in GitHub and we have already upgraded our project to the homologation environment. Remember that we need to make sure everything is working perfectly before we move into the production environment.

We have previously seen two ways to deploy our project: Git and Wordmove.

Deploy in production with Git

If you use servers with Git support, you need to add the remote repository, just like we did with the staging environment. Let’s use the WP Engine example again:

Adding the Remote Replacement: git remote add production git@git.wpengine.com:production/my-site.git

Deploy: git push production master

Deploy in production with wordmove

wordmove push -e production -all

Remember that you –all will have the entire project shipped to production, including the database, so always be aware of the context in which you are working. If you are just developing a plugin, you can override it –all by -p, for example.

The process from start to finish

Summarizing the whole process, what you’ve done so far was:

  • Configure the local environment
  • Install WP-CLI in the local environment to facilitate WordPress operations
  • Set up WordPress (local environment)
  • Create a repository in GitHub
  • Add the remote address of the repository (local environment)
  • Develop functionalities / changes (local environment)
  • Test the project (local environment)
  • Upload to GitHub
  • Go up to the homologation environment
  • Up to the production environment

Following all these steps can be a bit confusing and difficult at first, but then you will gain a lot in productivity.

Keep in mind that while making this whole setup a bit dull, you only need to do it once. After that, you can control the entire workflow with just a few commands, and with all those advantages we’ve seen in these two posts.

Comment below to exchange ideas.