Title: Containers Everywhere, or Why I’m Still Not Sure About Docker

---

December 22, 2014 was a day of mixed emotions for me. On one hand, the tech world was buzzing with excitement about containers and microservices. CoreOS had just released Rocket, and everyone seemed to be shifting towards using these newfangled container technologies like they were the next big thing. On the other hand, I found myself still skeptical.

I’d been working on a project that required running multiple services in different environments, and at first glance, Docker seemed like a great fit. But as I dove deeper into it, I couldn’t shake off the feeling that there was something not quite right about it all.

Let’s take a step back. Back then, I was working with a team on a platform that needed to support a variety of services and applications. We were using traditional VMs for isolation, but as our infrastructure grew, we started looking into Docker because it promised lightweight virtualization without the overhead of full VMs. The idea of being able to easily package and deploy applications seemed too good to be true.

I set up my first Docker containers on CoreOS, running a couple of services using Docker’s own runtime, Rocket. But as I delved deeper into the code, I started noticing some inconsistencies. For instance, environment variables weren’t behaving as expected in some cases. I spent hours debugging what should have been simple issues but turned out to be quirks and edge cases that made my head spin.

I remember arguing with a colleague about whether we should commit to Docker or stick with traditional VMs. My argument was mostly based on the feeling that there were too many moving parts, too much complexity for something that should ideally simplify our lives. The community hype around containers felt almost like it was pushing us into adopting something before it was truly battle-tested.

The fact that NASA announced plans to send humans to Mars just a few days earlier added an interesting layer of perspective. While I appreciated the ambition and the technology involved in such projects, I couldn’t help but wonder if we weren’t rushing into containerization with the same fervor as space exploration.

CoreOS’s Rocket runtime was still relatively new and had its own set of challenges. The idea that CoreOS might not have a future in the long term made me hesitant to fully commit to it. I mean, who would bet on an OS if they weren’t sure how things were going to shake out?

As the month progressed, we continued to wrestle with these technologies. We had meetings about whether Kubernetes was worth looking into, and I found myself spending more time reading about Docker’s command-line interface than I wanted to admit. It felt like a never-ending cycle of setup, configuration, and then debugging.

By the end of December, as I sat down to write this blog post, I realized that I was still not sure if containers were the silver bullet everyone seemed to think they were. Sure, Docker had some advantages, but it also came with its own set of complexities and quirks. I decided to take a more pragmatic approach: let’s stick with what we know works well while keeping an eye on these new technologies.

In the end, 2014 was about learning from both successes and failures. It was a year where containers went mainstream, but it also highlighted that sometimes sticking with the tried-and-true methods is better than jumping ship too quickly. As we moved into 2015, I hoped that the industry would mature around these technologies enough to make them truly reliable.

Now, if you’ll excuse me, I need to go back to setting up a couple of containers and see how they behave this time around.