CSS Terms: D.2 Software Engineering [PRIMARY], D.1 Programming Techniques
Microservices and Containers is an interesting book, albeit a flawed one. It addresses two currently important topics, but only loosely justifies putting the two topics in the same work. It is divided into three sections: first addressing microservices, the second containers, and the third offers a case study combining the two.
In the first part of the book, Kocher argues that for organizations with large, monolithic applications, adopting a microservice approach should prove beneficial because:
Part two of the book addresses containers, and in particular Docker. Containers are a lightweight method of packing an application together with all of the machinery (OS, database, files, environment settings, etc.) that support it. The connection between part one of the book and this part is tenuous, and consists in little more than Kocher's assertion that containers are a good way to run multiple microservices. Alternatives, like "serverless" computing in the cloud, are not examined. Nevertheless, these chapters do provide a good overview of container use, why you might prefer them to virtuals machines (they use resources more efficiently), and why Docker is the most popular container implementation.
At the end of the container section, the author includes two chapters on "Container Orchestration" and "Containers Management." These are summaries of the technical solutions available for deploying a suite of containers, each of which needs to be able to talk to all of the other containers, and for seeing how all of those containers are doing. There are brief but serviceable sections on Mesos, Kubernetes, and Docker Swarm, all of which manage suites of containers. There is also a section on the important topic of service discovery: with multiple containers spinning up and coming down all over your network of hundreds or thousands of microservices, how is a poor client machine supposed to know where to connect to what? The best solution, per Kocher, is to keep the knowledge in something like a load balancer, which fields requests for, say, user authentication, and knows where all the authentication servers are and which are busy, so it can route the client request to the best one.
The chapters illustrating how to use containers and microservices to build a helpdesk app provide useful examples of how to apply the more theoretical material from the first two sections. The conclusion of the book suddenly introduces the term DevOps, "another hot topic" (247). The topic is dealt with so briefly one can't help but suspect it was thrown in since it is a hot topic: if DevOps was going to be addressed in the book, it would have been much better to keep the topic in mind throughout, and discuss how microservices and containers enable DevOps practices as appropriate in each section.
Some contentions in the book don't seem to make sense. For instance, the author writes, "Docker... addresses the deployment and scalability problems by separating applications from the info structure dependencies. It addresses these problems with containers, which allow us to package the application with all its dependencies" (49). So Docker "separates" applications and their infrastructure dependencies by... packaging them together?
Another frustrating aspect of this book is the use of extensive screen dumps to pad out the material. For instance, the chapter on Docker commands is about 50% images of the output of such commands. A little of this sort of things is OK, but a little goes a long way, and the extensive use of these images here has gone way too far.
In summary, if one is unfamiliar with microservices and/or containers, this book provides a decent introduction to both topics. That being the case, with some better editing, a more robust link established between the two topics, and discussion of DevOps integrated throughout, this book could have gone from being a decent introduction to an excellent one.