The DevOps Toolkit Series Continues: 2.2 Is Born

The third installment in The DevOps Toolkit Series is public! Even though, while I’m writing this post, only 20% of The DevOps 2.2 Toolkit: Self-Healing Clusters is finished, I hope you’ll pick it up and send me your feedback. I need your help in setting the direction of the book. I need you to help me shape it into something great. I need you to help me make this book a community effort.

Please get it from leanpub.com/the-devops-2-2-toolkit. I’m waiting for your feedback.

What follows is the preface to The DevOps 2.2 Toolkit: Self-Healing Clusters book.

It seems that with each new book the scope gets fuzzier and less precise. When I started writing Test-Driven Java Development the scope of the whole book was done in advance. I had a team working with me. We defined the index and a short description of each chapter. From there on we worked on a schedule as most technical authors do. Then I started writing the second book. The scope was more obscure. I wanted to write about DevOps practices and processes and had only a very broad idea what will be the outcome. I knew that Docker had to be there. I knew that configuration management is a must. Microservices, centralized logging, and a few other practices and tools that I used in my projects were part of the initial scope. For that book I had no one behind me. There was no team but me, a lot of pizzas, an unknown number of cans of Red Bull, and many sleepless nights. The result is The DevOps 2.0 Toolkit: Automating the Continuous Deployment Pipeline with Containerized Microservices. With the third book, the initial scope became even more obscure. I started writing without a plan. It was supposed to be about cluster management. After a couple of months of work, I attended DockerCon in Seattle where we were presented with the new Docker Swarm Mode. My immediate reaction was to throw everything I wrote to trash and start over. I did not know what will the book be about except that it must be something about Docker Swarm. I was impressed with the new design. Something about Swarm ended up being The DevOps 2.1 Toolkit: Docker Swarm: Building, testing, deploying, and monitoring services inside Docker Swarm clusters. While working on it, I decided to make DevOps Toolkit Series. I thought that it would be great to record my experiences from different experiments, and from working with various companies and open source projects. So, naturally, I started thinking and planning the third installment in the series; The DevOps Toolkit 2.2. The only problem is that, this time, I truly don’t have a clue what will it be about. One idea was to do a deep comparison of different schedulers (e.g. Docker Swarm, Kubernetes, and Mesos/Maraton). The another was to explore serverless. Even though it is a terrible name (there are servers, we just don’t manage them), it is a great subject. The ideas kept coming but there was no clear winner. So, I decided not to define the scope. Instead, I defined some general objectives.

The goals I set in front of me is to build a self-adaptive and self-healing system based on Docker. The only problem is that I do not yet know how I will do that. There are different bits of practices and tools I’ve been using, but there is no clearly visible light at the end of the tunnel. Instead of defining what the book will be, I defined what I want to accomplish. You can think of this book as my recording of the journey. I will need to explore a lot. I will probably need to adopt some new tools and write some code myself. I don’t know, yet. Maybe it will turn out to be something completely different, and there will not be a self-adaptive and self-healing system. We’ll see. Think of this book as “Viktor’s diary while trying to do stuff.”

So, for now, the objectives are to go beyond a simple setup of a cluster, services, continuous deployment, and all the other things you probably already know. If you don’t, read my older books. I do not yet know the scope, nor I know what will be the result. Typically, when you write a book, you start with an outline and an index, write your chapters one by one and, at the end of the process, write a preface. It makes us (authors) look intelligent and in control. That is not the case. I did not write the preface at the end of the process (as an editor would advise me). I’m trying to be honest with you. I don’t have a plan.

You’ve been warned! I don’t know where this book is going nor whether I will manage to fulfill my self-defined objectives. I’ll do my best to outline the steps towards a self-adapting and self-healing system in the same way as I am exploring them myself.

The DevOps 2.2 Toolkit: Self-Healing Docker Clusters

If you liked this article, you might be interested in The DevOps 2.2 Toolkit: Self-Healing Docker Clusters book. The book goes beyond Docker and schedulers and tries to explore ways for building self-adaptive and self-healing Docker clusters. If you are a Docker user and want to explore advanced techniques for creating clusters and managing services, this book might be just what you’re looking for.

The book is still under development. If you choose to become early reader and influence the direction of the book, please get a copy from LeanPub. You will receive notifications whenever a new chapter is added.

Give the book a try and let me know what you think.

Advertisements

One thought on “The DevOps Toolkit Series Continues: 2.2 Is Born

  1. Pingback: The DevOps Toolkit Series Continues: 2.2 Is Born | Technology Conversations | Managed Project Office

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s