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:
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:
- I now rely on a third party service being around at the time I build my software
- 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
$GOPATH pointed at your project’s root folder:
- 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.
- Create a vendor directory in your project. The golang build system will look
$GOPATH/vendorfor packages before looking in the
- 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 getwould have put it in the src directory.
- Replace your
go getbuild step with a
git submodule updatecommand.
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.