Deploying with Git

(and not much else)

Jordan Bullivant

Contact: jordan@ghoststreet.co.nz

Some Caveats

I'm pretty new to this
We do "almost static" websites
Sufficiently complex projects should have CI

Why, though?

Why is this a good idea again?

Why, though?

1. It's easy

1. It's eas[y|ier]

FTP is mouse-heavy, annoying
Quit alt-tabbing
Editor integration

Why, though?

2. Version Consistency

Total consistency over multiple deployments
Single deploy path = harnessed laziness

"When the best way is also the simplest,
laziness and diligence are indistinguishable."

- Probably

Why, though?

3. Free repo backup

Deploy your entire project history
Offsite FTW
No real effort

Deploying with Git

Type 1

Basic Setup

You need a bare repo

What is a bare repo?

A repo which does not have an associated working directory.

What's wrong with the other type?

You can't push to a non-bare repo on a checked-out branch

How do I make one?

$ git init --bare reponame.git

Directory Structure of Normal Repo

Directory Structure of Bare Repo

Bare repos are usually to be checked-out to various locations
by multiple users. This is the part we want to automate.

Hooks

Hooks are a standard set of scripts
executed at various stages of git operations

We care about:

hooks/post-receive
hooks/post-update

Let's look at something useful:

Here's an example layout of the project

Something Useful

1. Make your bare repo


                    $ cd repos 

                    $ git init --bare myproj.git

Something Useful

2. Create post-receive hook


                        $ vim myproj.git/hooks/post-receive


                        #!/bin/sh 

                        GIT_WORK_TREE=webroot/www.myproj.com 

                        git checkout -f


                        $ chmod +x myproj.git/hooks/post-receive

Something Useful

3. Bind remote repo


                    $ git remote add origin ssh://me.sharedhost.com/home/me/repos/myproj.git

Note:

You can't clone the new repo in order to set
up your remotes automatically (like github).
There needs to be some data in it first.

Something Useful

4. Deploy instantly


                    $ git add . 

                    $ git commit -m "My rad changes" 

                    $ git push origin master

Deploying with Git

Type 2

Multiple Deployments

Deploying to Live and Dev
Locations Separately

Case 1: Separate Servers

Well, this is pretty easy. Just do the same thing
twice, then bind them with different aliases.


                        $ git remote add live    ssh://me.sharedhost.com/home/me/repos/myproj.git 

                        $ git remote add staging ssh://me.someotherhost.com/home/me/repos/myproj.git


                        $ git push live master


                        $ git push staging master

Done.

Deploying to Live and Dev
Locations Separately

Case 2: The Same Server

New example project layout:

The new hook: post-update


                    #!/bin/sh                                                     

                    LIVE_DIR="webroot/myproj"                                            

                    TEST_DIR="webroot/staging/myproj"                                    

                                                                                         

                    # Scrape branch name from incoming arguments                  

                    BRANCH=$( echo $1 | awk '{ split ($1,a,"/") } END { print a[3]; }' ) 

                                                                                         

                    # Set checkout directory based on branch name                 

                    case $BRANCH in                                                      

                        "master")  CHECKOUT_DIR="$LIVE_DIR" ;;                 

                        "staging") CHECKOUT_DIR="$TEST_DIR" ;;                 

                    esac                                                                 

                                                                                         

                    # Checkout this branch to appropriate directory               

                    GIT_WORK_TREE="$CHECKOUT_DIR"                                        

                    git checkout $BRANCH -f

Add remote alias:


                    $ git remote add origin ssh://me.sharedhost.com/home/me/repos/myproj.git

inherently supports

Branch + Merge based workflow

Branch + Merge Workflow

Always do new work on a dev branch


                    $ git checkout -b staging 

                    . . . 

                    $ git add . && git commit -m "My rad changes"

Preview on staging server


                        $ git push origin staging

Merge into master branch when ready


                        $ git checkout master 

                        $ git merge staging

Push to live server from master branch


                        $ git push origin master

Deploying with Git

Type 3

Complex Hooks

This method can be extended...

Some hook ideas:

Hooks can be in any language on the host machine
Reject incoming push based on RSpec results
Email interested parties
Interactive decision making via ssh
Re-generate online documentation
Restart/reconfigure app server

Going further...?

Well, no.

For sufficiently complex projects, you'll need...

Developer communication workflow
Continuous Integration
Project management feedback
(ie: tickets integration)

Complex projects will require
dedicated deployment solutions

(probably Capistrano)

Some final pointers

Set up ssh keys
$ git config http.receivepack true
Editor/IDE Integration

eg: Vim:


                        nnoremap <leader>gc :!git add . && git commit -m ""<left> 

                        nnoremap <leader>gp :!git push