$ cat post/compile-errors-clear-/-we-named-it-temporary-once-/-a-ghost-in-the-pipe.md
compile errors clear / we named it temporary once / a ghost in the pipe
Title: Kubernetes vs. CoreOS Fleet: Choosing the Right Tool for the Job
March 23, 2015 was just another day in the life of an engineering manager trying to keep up with a rapidly changing tech landscape. The Docker train had been rolling for about two years now, and microservices were finally starting to get traction. But amidst all this excitement, I found myself staring at two very different beasts: CoreOS Fleet and Kubernetes.
Fleet was all the rage in our Ops community. Simple, lightweight, and written in Go, it promised to be a breeze to use for deploying containerized applications. CoreOS had built it with DevOps in mind, and it felt like the right tool for us. But just around the corner was Google’s Kubernetes, an even more advanced orchestrator that seemed like it could take over the world.
Meanwhile, I was still wrestling with the complexities of running our own internal platform. We were a small team of engineers who had built our own infrastructure from scratch, and now we found ourselves in a position where choosing between these two tools felt like picking a side in some kind of tech civil war.
On one hand, Fleet seemed easy to use. It was minimalistic, and its simplicity was appealing. But as I delved deeper into the details, I couldn’t help but feel that it might be too simplistic for our needs. We needed something that could handle more complex deployments, like rolling updates and automated rollbacks.
On the other hand, Kubernetes was the buzzword du jour. It came with a hefty learning curve, and its complexity made it seem daunting at first glance. But as I started to explore the documentation and community resources, I began to see its true potential. Its powerful features and flexibility were unmatched by Fleet.
One of the biggest factors in my decision was the fact that Kubernetes was backed by Google, one of the largest tech companies in the world. This meant it had a lot of support and development going into it. The ecosystem around Kubernetes was also rapidly growing, with new tools and plugins being added all the time.
Another thing that swayed me towards Kubernetes was its strong community. People were actively contributing to the project, writing blog posts, giving talks, and sharing their experiences online. This meant I had a wealth of resources available to me if I needed help or wanted to get better at using the tool.
But the final straw was when I saw how Kubernetes handled services. In our previous projects, we often ran into issues with service discovery and load balancing. With Kubernetes, this seemed like it would be much easier to manage. The API for managing services looked clean and intuitive compared to what Fleet offered.
In the end, after weighing all these factors, I decided that Kubernetes was the better choice for us. It wasn’t just about the tool itself; it was also about having a platform that could scale with our needs. As we continued to grow as an engineering team, Kubernetes would provide us with the flexibility and power we needed.
Of course, this decision came with its own set of challenges. We had to learn a new system, which took time and effort. But I believed it was worth it in the long run. The transition wasn’t easy—debugging issues, arguing about best practices, and feeling like we were constantly playing catch-up—but it was necessary for our growth.
Looking back, choosing Kubernetes turned out to be one of the most important decisions we made that year. It set us up for success as we continued to scale our platform and handle more complex deployments. While there are always trade-offs in technology choices, I’m glad we took the plunge with Kubernetes.
This blog post captures a moment where the choice between different orchestration tools was crucial, reflecting both the excitement around new technologies and the challenges of choosing the right tool for your needs.