Handling golang third party dependancies robustly

I wrote recently about my thoughts on golang, concluding that although far from perfect, I quite like the language as it makes solving a certain class of problem much easier than traditional methods.

One of the things I was a bit dismissive of was how it manages packages. Whilst I'm not a fan of its prescriptive nature, it's out of the box behavior is in my mind just not compatible with delivering software  repeatedly and reliably for production software. However, it's fairly easy to work around this, I've not seen anyone use this particular approach, so I thought I'd document it for future people searching for a solution.

The problem is this: by default golang has a nice convenience feature that third party packages are referred to by their source location. For example, if I want to use GORM (a lightweight ORM for Go), which is hosted on github, I'll include it in my program by writing:

import "github.com/jinzhu/gorm"

And as a build stage I'll need to fetch the package by running the following command:

go get -v github.com/jinzhu/gorm

This command does is checkout the package into your $GOPATH/src directory at $GOPATH/src/github.com/jinzhu/gorm, doing a git clone of whatever their latest master code is.

On one hand this is very nice: you build in how to find and fetch third party dependencies. However, it's enforced two things that I don't want when I'm trying to build production software:

  1. I now rely on a third party service being around at the time I build my software
  2. The go get command always fetches the latest version, so I can't control what goes into my build

Both of these are not something I'm willing to accept in my production environment, where I want to know I can successfully build at any time, and I have full control over what goes into each build.

There is a feature of the golang build system you can use to solve this, just it's not that obvious to newcomers, and this alone isn't very useful, so here's my solution, bsaed on the assumption you're already using git for version control, and you have <code>$GOPATH</code> pointed at your project's root folder:

  1. Clone the project into your own code store repository. I always do this anyway, as you never know when third party projects will vanish or change significantly. 
  2. Create a vendor directory in your project. The golang build system will look $GOPATH/vendor for packages before looking in the $GOPATH/src directory.
  3. Add as a git submodule  the project at the appropriate point under vendor. For GORM that'd be vendor/github.com/jinzhu/gorm, similar to how "go get" would have put it in the src directory.
  4. Replace your "go get" build step with a "git submodule update" command.
  5. And voila, you're done. Using git submodules means you can control which commit on the third party project you're using, and by pointing it at your own mirror, you can ensure if your own infrastructure is there you can still deliver software regardless of external goings ons.

As a friend of mine pointed out, there are tools you can do to try and manage third party code into the vendor location, such as vndr, but the fewer tools I need to install to build a product the better - still, if you want to avoid the creation of directories yourself then you should give this a look.