Add the following new directories to our server. This is where our staging and production factory websites will be deployed to:

Exit out of our linux server. Run the following command to see a list of our locally installed ruby gems:

Notice we don't have Capistrano installed yet. Let's rectify that and install some other gems we'll use to add staging ability if we need it on a project:

Note that sometimes you have to try more than once to install ruby gems. If you get a timeout error just try it again. Go ahead and change directories to the new subversion project directory we had created in part three. Now we will setup our project for Capistrano deployment.

Now paste in the following deploy.rb code from this link into your deploy.rb file. Edit the line where it has set :repository and change the IP to your linux server. Save the file in nano.

Let's create a maintenance page so that if we ever need to take our site down to do server maintenance we're good to go:

Paste in the html code from this link and save the file in nano. Now let's create the folder structure for our different stages:

Let's create the mongrel_cluster.yml file for production:

Now let's setup staging:

We also need to create a config/environments/staging.rb file:

Now let's edit our database.yml file and add our stages (make sure to use your mysql user and pwd)

Paste in the following database info from the following link and save the file. Now we need to add the setup file for production:

Now we need to do the same for staging:

Now let's setup our fake domain so that we can test our deployment. Later we can replace a real domain in our staging.rb and production.rb files.

You can test it to see if our hosts file change worked by pinging our fake domains:

If you get your server's ip address we're good to go. Now let's test some Capistrano stuff out. You can see a list of the available Capistrano tasks by typing the following:

We are first interested in setting up our staging and production websites folder structure on our linux server. If we've setup things correctly so far the following commands will do that for us:

Now let's ssh back into our server and see if it worked:

You should see two folders, factory and qa.factory. Now let's install mysql (note that you will be prompted to enter a new password for root):

Next add the following line to your bash profile located in ~/.bash_profile

I like to manually create my databases and users in mysql, so let's add our databases for staging and production. You'll need to come up with a password you want to use that is secure. I'm just going to use 'password' for this example.

Exit out of the server. Now we need to change our rails project's config/database.yml, config/deploy/staging.rb, and config/deploy/production.rb files to reflect the new mysql user name of 'factory' and your new password.

Now let's add all of our rails code changes to subversion. You can see what files we need to add to subversion before we commit by typing the following:

The files with the '?' mark in front of them need to be added to subversion:

Now let's commit everything with a comment:

Now let's add our widget tunnel definition to our server and setup ssh keys for our server. Login to your server:

Exit out of the server. Now let's try deploying our staging application to the server. From the root of our factory application type the following:

You should see an error at the very bottom (/usr/sbin/monit: command not found). That's o.k. because we haven't setup monit yet. So go ahead and deploy production too:

Now add our factory tables to our staging and production databases using database migrations:

Now let's ssh back into our server and change directories to our deployed websites:

Now go to your browser on your Mac and type in http://qa.factory.com:3000. Our widget listing page should show up if everything is working. Now try creating a new widget! To stop the webrick server you just use CTRL_C. That's it for today. Next time we will get nginx to run our applications.

Now let's test our site to make sure everything is working correctly:

Open up your browser and try the site out using http://localhost:3000/widgets.

Then stop the web server using CTRL_C. Now let's go ahead and remove the index.html file:

Let's add the default route for our test website so that if you type in localhost:3000 it routes to our widget controller.:

Paste the following before the 'end' at the bottom of the file

Save the file and restart the server:

Try out our new route by going to http://localhost:3000. It should load our widgets list page.

Now let's install subversion:

Install ssh:

Create our repository:

Edit the svnserve config file:

Modify the following lines

Create the access rules file:

Paste in the following and save the file:

Create a svnserve startup file:

Paste in the following:

Make it executable:

Add it to the startup scripts:

Start the server:

Exit it out of our linux server. Now on our Mac we are going to edit our subversion config file

Add the following line inside the [tunnels] section

Save and exit nano. Now let's try everything out by creating a top level "projects" folder in our subversion repository from our Mac client:

If the directory got added were good to go. Now we can add our factory rails website. But before we do that lets setup a proper subversion folder structure using branches, tags, and trunk. Below is the folder structure I like (projects/[client_name]/[project_name])...feel free to change it however you'd like it to work. You could also create the folder structure manually locally on your Mac using mkdir and import it as the project.

Now let's import our factory project:

Now we should be able to list the folders using svn:

Now let's check out a copy of our factory project from our subversion server. First we'll create a new directory to hold our code called factorysvn:

Now you can edit your rails project and commit your changes using subversion. That's it for today. Next we will setup our rails project to use Capistrano and deploy it to our server!

SSH into your server:

By default, Debian and Ubuntu have five package repositories called main, restricted, universe, multiverse, and commercial. You will need the universe package repository. By default, it may or may not be enabled. To check, edit the /etc/apt/sources.list file (note that if you didn't install the aliases in part one you'll use "sudo nano" instead of sn below):

Uncomment the following two lines (assuming Ubuntu Feisty is installed):

Save and exit nano.

Now, lets make sure our server packages are up to date (note that in all of the installs for our Rails stack if you are prompted with "yes/no" say yes:

Install the GCC Tool Chain:

Now lets create a src directory to build from and get ruby and friends setup:

Install other core packages:

Install RubyGems:

Install Ruby on Rails and Dependencies (the following will download the latest framework):

If you need a specific version of rails here is an example which gets version 1.2.5:

Now let's install Mongrel (make sure you select the top ruby option when prompted):

Now we need to install some packages in preparation for Nginx:

Grab the latest build of Nginx:

Check that nginx is working and in your $PATH. The version command option should do the trick:

That's it for today. Next time we will setup the Nginx configuration files for our website and continue to add new functionality to our stack.

• SSH Keys
• Setting Up Aliases
• Nginx
• Ruby, RubyGems, Rails
• ImageMagick, RMagick
• Mongrel, Mongrel Cluster
• Monit
• AwStats
• Webmin
• Postfix
• MySQL
• Log Rotation
• Capistrano 2 Deployment
• Webistrano setup
• Amazon s3 backup
• Cron Job setup
• Subversion
• Shorewall Firewall

The usual disclaimer applies about not blaming me if things go awry on your machine. The following is working great for me right now on production servers. Your mileage may vary.

But, before we begin, please note that I am aware of the many automated ways that are available to setup a server such as RubyWorks by ThoughtWorks, the RailsMachine gem, Machinify, deprec, etc. When I first was learning about deployment I tried most of these out. Unfortunately, in my opinion, if you don't know how, where, and why things are installed on your server, it can lead to problems in the future. Trust me, it is much better to learn about how things work up front, that way you can deal with unique client requests that these automated solutions can't possibly account for. For example, I just recently deployed a Ruby on Rails forum that uses a Microsoft SQLServer 2000 database the client already had and wanted to use. If I hadn't learned some basic sysadmin skills, I would have been up a creek.

So let's get started. Here are my basic assumptions. You've got a brand new *nix server (the commands will assume Ubuntu Linux but the steps used can be applied to any *nix server) installed that is up and running. If you don't have a server I would recommend looking at SliceHost for small to medium sites. They are affordable and have been quite reliable for me (they run VPS slices on Xen servers). You should have the SSH credentials for the server. You also need a way to SSH into the server. For Mac it is built in (Terminal application), on a PC you can download Putty. Lets do a quick connection test and setup a new user on the server. Open up Terminal or Putty and connect to your server (you will be prompted for your password):

Now create a new user called deploy:

Now lets grant our new user sudo access. Type "visudo" and scroll down to the bottom and add our deploy user under the root section:

Save the file and exit out of the text editor. Type "exit" to get out of our ssh sesssion and return to our client machine.  Change directories to your home directory on your Mac:

Our first full step is one of convenience for Mac users and isn't absolutely necessary. We are going to setup SSH keys so that we won't be prompted for a password every time we want to SSH into our server. This will make our Capistrano deployments seamless later on. First we need to create a public key on our Mac. You can generate an SSH RSA key with your email as an added comment using the ssh-keygen command. The following command will create two files, id_rsa and id_rsa.pub, in your .ssh/ directory:

Now lets create the .ssh directory on our server. We can actually create this folder without executing any commands on the Linux server. We use SSH to remotely execute the command from our client machine so you don't need to run the following command on your Linux server.

With the .ssh directory prepared on your Linux server you need to copy your public key to the .ssh/authorized_keys file. Then we make sure the permissions on that file allow only the deploy user read and write access:

Now you have created and deployed your SSH keypair. Using the keys you have just created you can deploy your apps effortlessly with Capistrano. Now lets modify the default port and login permissions for SSH to really lock it down. SSH into the server again, note that this time you won't be prompted for a password!

Edit the SSHD File:

Edit the line that looks like this:

Change it to:

Edit the line that says PermitRootLogin yes and change it to:

Then save the file and quit the editor. And don’t forget to restart the SSH server daemon:

From now on you won't be able to SSH into your server as root which is a good thing. You will also have to pass the port number to ssh when logging in from now on. We added this for a little more security. This is how to add the port when logging in now:

For you security buffs out there, yes I know this is security through obscurity. We will lock our server down with a firewall later on. If you are on a Mac, may I suggest you download the great terminal replacement application called iTerm. What I really like about iTerm is that you can have multiple SSH instances running in different tabs by hitting (APPLE + T). You can also add bookmarks for all of the servers you need to constantly SSH into. Once you've setup your SSH keys and added your login information to iTerm, you just click on the bookmark and you're logged into your server! Now that's convenience.

Let's go ahead and log back into our server and add some bash command aliases to make our life easier:

Let's create a bash profile:

Copy and paste into the nano text editor the following commands (note that some of these commands are Debian/Ubuntu specific and won't work yet until we complete our Rails stack):

Now exit and save the file. Type the following to load the changes we made:

Now try the free command to see how much memory we have available on our server (the last line is what you want to look at (the used/free columns):

If it worked you should see some output columns in your terminal window. Now go ahead and type exit and log out of your server. We're done for today. Next time we will get busy installing software on our shiny new server.