UPDATE: There have been some updates to my Revel Heroku Buildpack that make it work better and with newer versions of Revel. Check out the details.
[Revel][1] is a Play-like web framework for Go. I'm new to the Go programming language but I've heard good things. So I thought I'd take Revel for a spin and get it working on Heroku. Luckily there is already a [Go Buildpack][2] and [a great article on how to use it][3].
To get Revel working on Heroku I had to [make a few changes to Revel][4] and create a [modified buildpack][5]. But it all works! Lets walk through the steps you can follow to deploy Revel apps on Heroku.
First lets get a simple Revel app working locally.
**Step 1)** [Install Go][6]
**Step 2)** [Install Mercurial][7]
**Step 3)** [Install Git][8]
**Step 4)** Create a new directory that will contain everything:
```bash
mkdir ~/go
```
**Step 5)** This new "go" directory will be your "GOPATH" so set that environment variable:
```bash
export GOPATH=~/go
```
**Step 6)** In the newly created "go" directory, get the original Revel source and my changes:
```bash
go get github.com/robfig/revel
go get github.com/jamesward/revel
```
**Step 7)** Build the "revel" command:
```bash
go build -o bin/revel github.com/jamesward/revel/cmd
```
**Step 8)** Grab my "hellorevel" sample app:
```bash
go get github.com/jamesward/hellorevel
```
**Step 9)** Start the local Revel server:
```bash
bin/revel run github.com/jamesward/hellorevel
```
**Step 10)** In your browser navigate to:
You should see a "hello, Revel" message. Lets walk through this simple app so you can get an idea of how it works.
The request you just made is mapped to code through the "conf/routes" file which contains:
```
# Routes
# This file defines all application routes (Higher priority routes first)
# ~~~~
GET / Application.Index
```
This tells Revel to handle HTTP GET requests to "/" with the "Application.Index" controller.
The "Application.Index" function is defined in the "app/controllers/app.go" file and contains:
```go
package controllers
import (
"github.com/robfig/revel"
)
type Application struct {
*rev.Controller
}
func (c Application) Index() rev.Result {
message := "hello, Revel"
return c.Render(message)
}
```
The "Index()" function creates a "message" string of "hello, Revel" and then returns the rendered template which received the "message" as a parameter.
The "app/views/Application/Index.html" template is used to get the HTML for the "Application.Index()" controller and contains:
```html4strict
{{.message}}
```
This uses Go templates and uses the "message" parameter.
Feel free to make changes to the template and controller to see how Revel auto-recompiles the source.
Ok, now that you have the application running locally, lets deploy it on Heroku.
**Step 1)** [Signup for a free Heroku account][9]
**Step 2)** [Install the Heroku Toolbelt][10]
**Step 3)** Login to Heroku from the command line (this should also setup your SSH keys if you haven't done so already):
```bash
heroku login
```
**Step 4)** Enter the directory for the "hellorevel" app and create a new application on Heroku which will use the Revel Buildpack:
```bash
cd ~/go/src/github.com/jamesward/hellorevel
heroku create --buildpack https://github.com/jamesward/heroku-buildpack-go-revel.git
```
**Step 5)** Upload the app to Heroku using Git:
```bash
git push heroku master
```
This will upload the application source, pull in all of the dependencies, and then deploy the application on Heroku. That process will look something like this:
```bash
jamesw@T420s:~/go/src/github.com/jamesward/hellorevel$ git push heroku master
Counting objects: 25, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (19/19), done.
Writing objects: 100% (25/25), 2.46 KiB, done.
Total 25 (delta 2), reused 0 (delta 0)
-----> Heroku receiving push
-----> Fetching custom git buildpack... done
-----> Revel app detected
-----> Installing Go 1.0.3... done
Installing Virtualenv...running virtualenv done
Installing Mercurial... done
-----> Copying src to .go/src/pkg/_app
-----> Getting and building Revel
-----> Discovering process types
Procfile declares types -> (none)
Default types for Revel -> web
-----> Compiled slug size: 31.0MB
-----> Launching... done, v4
http://polar-cove-5542.herokuapp.com deployed to Heroku
To git@heroku.com:polar-cove-5542.git
* [new branch] master -> master
```
**Step 6)** Check out your Revel app on the cloud by running:
```bash
heroku open
```
That's it! Deployment of Revel apps couldn't be easier! Let me know if you have any questions or feedback on this. Thanks!
[1]: http://robfig.github.com/revel/
[2]: https://github.com/kr/heroku-buildpack-go
[3]: http://mmcgrana.github.com/2012/09/getting-started-with-go-on-heroku.html
[4]: https://github.com/jamesward/revel
[5]: https://github.com/jamesward/heroku-buildpack-go-revel
[6]: http://golang.org/doc/install
[7]: http://mercurial.selenic.com/wiki/Download
[8]: http://git-scm.com/download
[9]: http://heroku.com/signup
[10]: http://toolbelt.heroku.com