Jaysinh’s own heed

Book review ‘Docker Up & Running’

2017-12-05T05:56:32+00:00

In the modern era of software engineering, terms are coined with a new wrapper. Such wrappers are required to make bread-and-butter out of it. Sometimes good marketed terms are adopted as best practices. I was having a lot of confusion about this Docker technology. Even I was unfamiliar with the concept of containers. My certain goal was to get a higher level overview first and then come to a conclusion. I started reading about the Docker from its official getting started guide. It helped me to host this blog using Docker, but I was expecting some more in-depth overview. With that reason, I decided to look for better resources. By reading some Quora posts and Goodreads reviews, I decided to read “Docker Up & Running by K. Matthias and S. Kane”. I am sharing my reading experience here.

TL;DR

The book provides a nice overview of Docker toolchain. It is not a reference book. Even though few options are deprecated, I will advise you to read this book and then refer the official documentation to get familiar with the latest development.

Detailed overview

I got a printed copy at nearly 450 INR (roughly rounding to 7 USD, where 1 USD = 65 INR) from Amazon. The prize is fairly acceptable with respect to the print quality. The book begins with a little history of containers (Docker is an implementation of the container). Initial chapters give a higher level overview of Docker tools combining Docker engine, Docker image, Docker registry, Docker compose and Docker container. Authors have pointed out situations where Docker is not suitable. I insist you do not skip that topic. I skipped the dedicated chapter on installing Docker. I will advise you to skip irrelevant topics because the chapters are not interlinked. You should read chapter 5 discussing the behavior of the container. That chapter cleared many of my confusions. Somehow I got lost in between, but re-reading helped. Such chapters are enough to get a general idea about Docker containers and images. Next chapters are focused more on best practices to setup the Docker engine. Frankly, I was not aware of possible ways to debug, log or monitor containers at runtime. This book points few expected production glitches that you should keep in mind. I didn’t like the depicted testing workflow by authors. I will look for some other references which highlight more strategies to construct your test workflow. If you are aware of any, please share them with me via e-mail. I know about achieving auto-scaling using various orchestration tools. This book provides step by step guidance on configuring and using them. Mentioned tools are Docker Swarm, Centurion and Amazon EC2 container service. Unfortunately, the book is missing Kubernets and Helios here. As a part of advanced topics, you will find a comparison of various filesystems with a shallow overview of how Docker engine interacts with them. The same chapter is discussing available execution drivers and introduces LXC as another container technology. This API option is deprecated by Docker version 1.8 which makes libcontainer the only dependency. I learned how Docker containers provide the virtualization layer using Namespaces. Docker limits the execution of container using CGroups (Control Groups). Namespaces and CGroups are GNU/Linux level dependencies used by Docker under the hood. If you are an API developer, then you should not skip Chapter 11. This chapter discusses two well-followed patterns Twelve-Factor App and The Reactive manifesto. These guidelines are helpful while designing the architecture of your services. The book concludes with further challenges of using Docker as a container tool.

One typo I found at page number 123, second last line.

expore some of the tools...

Here, expore is a typo and it should be

explore some of the tools...

I have submitted it to the official errata. At the time of writing this post, it has not confirmed by authors. Hope they will confirm it soon.

Who should read this book?

Developers who want to get an in-depth overview of the Docker technology.
If you set up deployment clusters using Docker, then this book will help you to get an overview of Docker engine internals. You will find security and performance guidelines.
This is not a reference book. If you are well familiar with Docker, then this book will not be useful. In that case, the Docker documentation is the best reference.
I assume Docker was not supporting Windows platform natively when the book was written. The book focuses on GNU/Linux platform. It highlights ways to run Docker on Windows using VMs and Boot2Docker for Non-Linux VM-based servers.

What to keep in mind?

Docker is changing rapidly. There will be situations where mentioned options are deprecated. In such situation, you have to browse the latest Docker documentation and try to follow them.
You will be able to understand the official documentation better after reading this book.

Conclusion

Your GNU/Linux skills are your Docker skills. Once you understand what the Docker is, then your decisions will become more mature.

Proofreaders: Dhavan Vaidya, Polprog

Printed Copy

Book review ‘Introduction to the Command Line’

2017-02-28T00:00:00+00:00

tl;dr

Every chapter will introduce a bunch of comands and will point to its respective documentation for further learning. You should expect chapters describing from the grep command to GNU Octave which is a scientific programming language. The chapters are independent of each other. The book is must read if you are new to the GNU/Linux command line. If you are at the intermediate level, then too investing time in reading this book will unveil a few surprises for you.

Detailed review

The book is community driven and published under FLOSS Manual. It is a collaborative effort of the FSF community. The fun part is you can contribute to this book by adding new chapters or by improving an existing one. I fixed one typo in this book after reading. The best introduction is crafted comparing GUI based image editing tools with the most unknown command convert. It conveys the importance of command line well to the reader. Initial chapters will present the overview of various GNU/bash commands. From my personal experience, you have to use mentioned commands in this chapter daily. The chapter of Command history shortcuts depicts geeky shell patterns. I will advise not to skip that chapter and read through once. The advanced section was not much advance for me. It demonstrates ssh and related commands like scp and more. I appreciated the preference of using GNU Screen though I use tmux over it. If you are possessed by moving around on multiple directories simultaneously, then directory stacks under Moving Again section is worth scanning. This functionality is saving dozens of my keystrokes now. There is one entire division dedicated to various editors. That section is not limited to GNU Emacs or vim, but also briefs GNU NANO, Kedit and Gedit. This section does not compare the pros and cons of several editors, but describes basics of each which should be counted as a good part. I skipped this part because I am comfortable with vim editor at present and don’t want to invest much in others.

The scripting section turned out to be the most interesting division for me. Though I was aware about the tools like sed and language awk I was not using them often. Reading their chapters and implementing mentioned examples built little confidence in me. Now I am much comfortable in utilizing them. The irregular Regular expressions are everywhere. You should not pass over this section and pay careful attention to various examples. It is worth to invest your time in this segment.

This is not the ending. This book presents a glimpse of various scripting level programming languages like Perl, Python and Ruby. Because I am a python developer for a few years and I was not much interested in other languages, I skipped this section. A shallow introduction to GNU Octave is nice to study if you are interested in knowing a little about this scientific programming language.

How to read this book?

Do not read to read. This book contains nice shell examples. By merely reading, you will end up without bringing about anything meaningful. I will advise you to interpret the description first, observe the examples and then implement them on your own. If you have any confusions, read the example and description again or obtain help from man or info are the best options. To remember, I revised the important chapters more than once in a week. It helped me to refresh what I learned before. I will attempt to re-read the important sections once again after a few days to refresh my memory.

What is missing?

Considerably, the book is nicely written, equally distributed and largely acceptable, but I would prefer to have a small set exercises section at the end of each topic. Exercise might help the reader to identify their weak points early and refer on them again if they desire to.

Typo / Mistakes

I didn’t encounter any sever mistakes except one typo. The section of Userful customizations on page number 80 of my printed version, contains following example:

function manyargs { $arg=$1 shift ... }

Here, $arg is a misprint. A shell variable is never assigned with $. It should be args=$1. I myself has corrected the typographical error in the book. This change will be published maybe in the next release of this book.

If you are encountering any mistakes while reading, I request you to fix the change here. The interface for editing the book is beginner friendly. It took less than 5 minutes to drive the change.