This book offers a worthwhile introduction to fundamental devops practices that relate to continuous delivery: continuous integration, automated testing, configuration management, clustering, and so on. It’s like a good introductory university course, only with plain English. And it’s even applicable to those of us who have used a CD pipeline a lot without having put much thought into it.

I picked it up in a Humble Ebook Bundle on devops almost two years ago. In classic Fritz style, this is the first book of any of them that I’ve read (cheap accumulation that finally paid off!). The title put me off because I was worried that it would be just a manual for Jenkins with a little bit of Docker thrown in, but it was short so I decided to dip in because I’ve been frustrated with a bunch of other books that are taking me a long time to finish.

That’s correct, my solution for the problem of having four books in progress was to start a fifth book.

Back to the content: for each topic, there’s a description of what the practice is, without reaching for jargon that is only understandable once you know enough to make the description redundant. This is something missing from most devops introductions I’ve encountered.

There is enough in the description of each practice to learn why it is important: what problems does each practice address? For instance, we could end up releasing the wrong version of an app if there are multiple changes in rapid succession; we can employ versioning strategies such as semantic versioning to address this.

I appreciate this because I personally find it very difficult to work with a practice or technology until I can understand whether I’m using it in the right context.

A nice touch is that in addition to giving a practical example, it also discusses alternatives. For instance, clustering is demonstrated with Docker Swarm, but there is a really nice comparison table showing the difference between Docker Swarm, Kubernetes, and Apache Mesos. Containerisation is central to the book, but there’s also a few paragraphs explaining how virtualisation came before, and what containerisation offers instead.

The examples are very practical and therefore necessarily located in specific technologies: Docker, Jenkins, Ansible, Cucumber, Docker Swarm. However the lessons demonstrated are applicable beyond those choices. I am unlikely to use Ansible (having tried it on some older projects), but the more abstract material on configuration management was still valuable.

Chapter Nine on Advanced CD covered in a light but useful way some topics that take the reader deep: understanding database migrations (not just, “hey look, Rails does this for you!”); rolling back; blue-green deployments; canary deployments; working with legacy systems. This chapter was a joy. It seemed like every new heading surprised me as I remembered that I’d always wanted to do a bit of reading on the topic. The actual content is light, but the further reading on each topic is not.

In general, I was pleased with the regular references to further reading throughout the book. As a result, I now have Michael Nygard’s Release It! on my to-read list and the Flickr talk on how they influenced Yahoo! towards CD after they were acquired.

In contrast to all these good points, I have only minor complaints. The material on automated testing leans towards an acceptance testing approach that seems unrelated to the basics of CD. I haven’t yet worked with a stakeholder who was capable of or interested in writing acceptance tests that could be turned into automated tests (not even with magical Cucumber-like syntax), and I really don’t think that it’s a necessary part of continuous delivery. I don’t dispute the value of end-to-end tests, but I don’t think it’s wise to set beginners up with the impression that stakeholders will be able to contribute in this way. That’s only topic out of many though.

I am very pleased that this book made it to the top of my reading list - albeit accidentally - and would recommend it to developers who have not designed a CD pipeline and put thought into the different options that they could take; i.e. most developers.

You can find Continuous Delivery with Docker and Jenkins on sale here.