Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Microservices and containers
Kocher P., Addison-Wesley Professional, Boston, MA, 2018. 304 pp. Type: Book (978-0-134598-38-3)
Date Reviewed: Oct 12 2018

Microservices and containers is an interesting book, albeit a flawed one. It addresses two important topics, but only loosely justifies putting the two topics in the same work. It is divided into three sections: the first addresses microservices, the second containers, and the third offers a case study combining the two.

In the first part, Kocher argues why organizations with large, monolithic applications will benefit from adopting a microservices approach:

  • They are simpler to understand than a monolithic application.
  • They are easier to scale: only the part of the overall application that is the bottleneck needs to be given more resources.
  • It is easier to do continuous delivery when updating microservices, rather than an entire monolithic application.
  • There will be a looser coupling between components of the system when it is built on microservices.
  • Bugs are isolated in a microservice and can’t bring down all components of a system.
  • They enable more freedom of choice among technologies, as each microservice team can choose different languages, libraries, databases, and so on.

Part 2 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, and so on) that supports it. The connection between Parts 1 and 2 is tenuous and is little more than Kocher’s assertion that containers are a good way to run multiple microservices. Alternatives such as 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 virtual 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 book’s conclusion suddenly introduces DevOps, “another hot topic.” DevOps is dealt with so briefly that one can’t help but suspect it was thrown because it’s 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.

Some contentions in the book don’t seem to make sense, for instance:

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.

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 the material. For instance, about 50 percent of the chapter on Docker commands is images of the output of such commands. A little of this sort of thing is okay, 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.

More reviews about this item: Amazon

Reviewer:  Eugene Callahan Review #: CR146276 (1812-0612)
Bookmark and Share
  Reviewer Selected
Featured Reviewer
 
 
General (D.2.0 )
 
 
General (D.1.0 )
 
Would you recommend this review?
yes
no
Other reviews under "General": Date
Development of distributed software
Shatz S. (ed), Macmillan Publishing Co., Inc., Indianapolis, IN, 1993. Type: Book (9780024096111)
Aug 1 1994
Fundamentals of software engineering
Ghezzi C., Jazayeri M., Mandrioli D., Prentice-Hall, Inc., Upper Saddle River, NJ, 1991. Type: Book (013820432)
Jul 1 1992
Software engineering
Sodhi J., TAB Books, Blue Ridge Summit, PA, 1991. Type: Book (9780830633425)
Feb 1 1992
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy