Setting Up A Staging Environment

Creating a staging environment is specific to your production environment.

There are many different operating systems you can run on a server. Fortrabbit runs Debian Squeeze on their servers, and since we are trying to match them, I decided to run it as well.

I’ll use Vagrant to set this up. Don’t worry if you’ve never used Vagrant; we will not do anything advanced. Make sure you have VirtualBox and Vagrant installed (Vagrant is a CLI for VirtualBox; so VirtualBox is required).

Vagrant takes a virtual snapshot of an operating system as a base ‘box’, and you can then create multiple VMs from that image. So first, we need to download the base box for Debian Squeeze. I’m not exactly sure where my copy comes from, so I uploaded it to DropBox for you to download and use. To install, open up a terminal window and type:

vagrant box add debian https://dl.dropbox.com/u/30949096/debian.box

This adds the box to Vagrant with the name, ‘debian’. We can now create an instance of this box for our staging area. First, let’s create a new folder:

mkdir ~/staging_servercd ~/staging_server

Next, create the Vagrant config file by typing:

vagrant init debian

This creates a config file, named “VagrantFile”, which contains all the settings for you server. It looks pretty crowded when you open it, but most of the lines are comments. You only need to uncomment the line that says: config.vm.network :bridged. Deleting all other comments leaves you with a file that looks like this:

Vagrant::Config.run do |config|    config.vm.box = "debian"    config.vm.network :bridgedend

These options tell Vagrant to create a new virtual machine based on our Debian Squeeze base box. It then sets the network mode to ‘bridged’. A VM with a bridged network appears as a new physical machine to your router, so it automatically retrieves its own IP address. This lets you access the machine from any device on your network (possibly outside of your network if you configure your router).

Now, we can launch our VM with the command: “vagrant up” (without the quotes).

You should see the output of Vagrant creating your VM. If your computer has multiple NICs connected to the network, Vagrant will prompt you to pick the NIC to bridge.

We’ll use SSH to login, but we’ll need to use Vagrant’s built-in “vagrant ssh” command to login. According to Vagrant best practices, all boxes should have a user named “vagrant” with the password, for both root and vagrant, “vagrant”. The vagrant user is added as a sudo user who doesn’t need to enter a password, so you can directly use sudo commands.

Let’s move on and set up the server’s software.

The Software

Fortrabbit’s setup includes:

• Apache 2.2
• PHP 5.4
• Composer

Additionally, they use the dotdeb repository to install the bulk of it. For those unfamiliar, dotdeb is a project by Guillaume Plessis that installs the most up-to-date versions of popular web server packages.

We’re ready to begin. Ensure that your terminal window is open and logged into the server through SSH. First, add the dotdeb repo to APT (the package manager) by adding a new file to sources.d directory:

sudo vim /etc/apt/sources.list.d/dotdeb.list

This opens a new file named dotdeb.list in vim (a text editor). The name is not important because all files in this directory are read into APT. We need to add four lines to this file. If you have never used VIM, just type “i” to enter insert mode and copy/paste the next four lines:

deb https://packages.dotdeb.org squeeze alldeb-src https://packages.dotdeb.org squeeze alldeb https://packages.dotdeb.org squeeze-php54 alldeb-src https://packages.dotdeb.org squeeze-php54 all

To save, press the esc key and type :wq. That is the command to write and quit, which basically means save and exit.

Pressing enter saves the file and returns you to the command line.

We have now added the repos, but we still need to add the signature before we can use them. Type the following to add the GNU key:

curl https://www.dotdeb.org/dotdeb.gpg | sudo apt-key add -

This downloads the dotdeb key and adds it as a signed source. Now update APT to pull in the new package by typing:

sudo apt-get update

This can take a minute or so, but you’ll have all the dotdeb packages listed in APT when it finishes. Because of how dotdeb is setup and how APT dependencies are loaded, we can install Apache and PHP at the same time by typing:

sudo apt-get install php5

With this single line, APT installs and configures Apache2 and PHP5. If you use the Fortrabbit’s memcache add-on, then you can install it with:

sudo apt-get install memcached

But I’m not going to go into memcache in our example in this article.

Now we need to install the extensions that Fortrabbit uses. Run the following command:

sudo apt-get install php5-xdebug php5-tidy php5-sqlite php5-redis php5-pgsql \php5-mysqlnd php5-memcache php5-memcached php5-mcrypt php5-imagick php5-http \php5-gmp php5-gd php5-curl php5-apc php5-intl

The last thing we need to install is Composer. I am going to install it globally because we will use it in a few different locations. The commands to globally install Composer are:

curl -s https://getcomposer.org/installer | phpsudo mv composer.phar /usr/local/bin/composer

The first command downloads and executes the installer; the second command moves Composer to the bin folder so that we can use it without declaring the path. Let’s move on to the configuration.

Setting Up Apache

Chances are good that you may be working on more than one project. If this is the case, having a staging server for each project creates a lot of overhead. To allow for multiple sites on a single server, we need to add name-based virtual hosts to Apache, and should separate directories and repos for each project.

Let’s begin with a virtual host.

I am going to continue using vim, but know that if you want to work in your own programs, you can either copy and paste or save it in the staging_server folder you created on your computer.

That folder is shared to your VM, and you can access the files in the vagrant root directory. You can then use: sudo cp /vagrant/file newfile or sudo mv /vagrant/filee newfile to copy or move the files, respectively.

To create a new virtual host, we need to create a file in the /etc/apache2/sites-available/ directory. To do this with VIM, type the following:

sudo vim /etc/apache2/sites-available/demo.site

Inside, enter the following (remember press “i” for insert mode):

<VirtualHost *:80>ServerAdmin [email protected] demo.devDocumentRoot /var/www/demo<Directory /var/www/demo>Options Indexes FollowSymLinks MultiViewsAllowOverride ALLOrder allow,denyallow from all</Directory>ErrorLog ${APACHE_LOG_DIR}/demo.logLogLevel debug</VirtualHost>

The first line declares a virtual host that listens for requests on any IP at port 80. Next, we set the server’s admin email and the server name. The email is for error reporting purposes, and the server name option tells Apache when to read this virtual host. Regular virtual hosts work off of IPs. For example, each vhost listens on a different IP; that’s how Apache differentiates them.

Since you probably only have one IP, we can use name-based Virtual hosts, allowing you to provide a different name on the same IP.

In our example, any requests directed at demo.dev are picked up by this virtual host.

The next line sets the document’s root folder. This is where Apache retrieves files for this vhost. The statements inside the Directory directive sets permissions for this vhost. I won’t go into too much detail, but we first set the directories Apache options, then we set what can be overridden in an .htaccess file, and finally we set who can access the site (everyone can in our case).

The last two lines tell Apache what to name the log file and what to write to the log. Our log file is called demo.log in the Apache log folder located at /var/log/apache2/ on this VM.

To enable this vhost, type the following:

sudo a2ensite demo.site

This creates a symlink between the file in the sites-available folder to a file in the sites-enabled folder. After running this command, you’re prompted to restart Apache. You’ll get an error if you try to restart Apache because we haven’t created the site’s directory. This is easily fixed buy creating the demo folder that we referenced in the vhost file:

sudo mkdir /var/www/demo

We don’t want the root user to own the folder, so change it to the vagrant user with the chown command:

sudo chown -R vagrant:vagrant /var/www/demo

Now restart Apache:

sudo service apache2 restart</code>

Our new site should now be fully functional. Our next step is to setup GIT.

Following up With Some GIT Magic

Make sure that you are in the home directory by typing cd ~. Create a new folder for the repo: mkdir demo.git, enter the folder, and initialize a new, bare GIT repo:

cd demo.gitgit init --bare

A bare repo is essentially a standard repo without a working directory. If you want to learn more about GIT, check out Andrew Burgess’ video series.

We now need the ability to push code to the site’s folder, and there are many ways to accomplish this. But I like to make things look as close as possible to the service I am emulating. Here is a picture of fortrabbit’s git process taken from their site: