BOOK REVIEW

We are familiar with monolithic applications like Chrome, MATLAB, Microsoft Office, etc. These software provide a single executable file and we install them on our computer. Kubernetes itself is a distributed software. It has many parts. Different parts live in different places. For example, Kubernetes has components like Schedular, Controller, etcd, API-Server, Kubelet, and Kubeproxy. These components could live in a single node. In that case, it would be a single-node cluster. When it comes to a multi-node cluster, there is generally a control plane node, and other nodes are designated as worker nodes. Components like Schedular, Controller, etcd and API-Server live in the control plane node, whereas kubelet and kubeproxy live in the worker nodes. In order to work with the cluster, we use a config file named as yaml or a manifest file. I have counted that there are around 42 (For example, Deployment, Service, Daemonset, RBAC, ConfigMaps/Secrets, Persistent Volumes, networking policies) default resource types in Kubernetes. The most important resource types are Deployment and Service. When we upload the config files to the API server, it stores them in the etcd database. If it is a Deployment, then the Scheduler decides where to schedule pods in worker nodes. Kubelet watches the API server and helps spin up the pods. It is also responsible for the life cycle management of pods. Kubeproxy watches the API server for Service type resources. When there is a new Service, it inserts networking rules in the iptables. 

This amazing book has dedicated chapters for each important concept to get you started with Kubernetes. However, it doesn't go into very much detail on some topics. It is reasonable; otherwise, it would have been an unreadable book. When you complete reading all the chapters, just read some online blogs to understand deeper topics.  

Docker is so smooth and beginner-friendly that I couldn't see how it is internally working. Docker commands are so well organized that when I used them to containerize my microservice-based chatbot application, I did it without knowing much about Docker's underlying structure. However, I needed a deep dive because I felt that Docker was hiding a lot of information.

After reading this book, I now have a deep understanding of how Docker virtualizes the OS, creates virtual networks, enables containers to communicate, how Swarm works, how volumes are used to store data for stateful applications, and how Docker enforces security.

Now, whenever I run a Docker command, I know exactly what to expect and where to look to inspect the effects.

I'm now confident in using the tool. Thanks to Nigel Poulton for this fantastic book! For people who want a deeper understanding, such as how Docker virtualizes the OS, I recommend reading this book. 

When I started learning the C programming language, I had this strange experience of writing a function to add two numbers. Everyone who has been exposed to programming languages knows about it—a function can take two numbers as input and return their sum as output. We know that computers are dumb, but somehow, even though we don’t define what summation is or how to perform it, the computer still provides accurate results. So the question arises: how does it know?

This book has a nice logical buildup. It starts with bits, and then explains bytes. After that, it talks about capacitors, transistors, logic gates, half adders, full adders, registers, and the arithmetic logic unit—as if it is reinventing the CPU. After all the explanations, it shows how a simple addition goes through complex steps such as loading data into memory, loading data from memory to a register, performing the addition, and sending the result back to memory.

It also explains how memory is built and how it stores data as 1s and 0s. At the end, it shows how the monitor, memory, processor, disk, and other peripheral devices are synchronized and work together.

Reading this book was an amazing experience. I learned everything about computer architecture from it. It gives both a pixel-level view and a big-picture view. I love this book. For people who want to learn about computer architecture, I would definitely recommend this book.