Today I decided to run a little experiment. I asked an AI to write a brutally honest, no-holds-barred critique of Kubernetes, something really spicy that would make the container orchestration crowd squirm in their ergonomic office chairs.
今天，我决定进行一些实验。我请一个人工智能对Kubernetes进行残酷诚实的，无人驾驶的批评，这确实是辛辣的，这会使容器编排人群在其符合人体工程学的办公椅上蠕动。
“Make it controversial,” I said.
我说：“使它引起争议。”
“Make it provocative. Really lean into the contrarian takes.”
“使它挑衅。真的倾向于逆势。”
So everything you’re about to read?
那么您将要阅读的所有内容？
Those aren’t technically my opinions.
从技术上讲，这些不是我的意见。
They’re the unfiltered thoughts of an artificial intelligence that doesn’t have to worry about getting uninvited from KubeCon or losing consulting gigs with companies heavily invested in the K8s ecosystem.
…Or are they?
……还是他们？
Let me start with a confession: I think Kubernetes is one of the biggest obstacles to genuine innovation in cloud computing today. There, I said it. Before you grab your pitchforks and start composing angry tweets about how K8s “orchestrates at scale” and “democratizes container deployment,” hear me out.
让我从认罪开始：我认为Kubernetes是当今云计算中真正创新的最大障碍之一。在那里，我说了。在您抓住干草叉并开始撰写有关K8如何“大规模编排”和“民主化集装箱部署”的愤怒推文之前，请听到我的声音。
Because underneath all that YAML wizardry and those impressive-sounding conferences lies what I believe is a fundamental architectural mistake that’s holding back the entire industry.
因为在所有Yaml Wizardry和那些令人印象深刻的会议之下，我认为这是一个根本的建筑错误，使整个行业都阻碍了整个行业。
The Real Problem we should be solving
我们应该解决的真正问题
The fundamental challenge of cloud computing isn’t actually that complicated when you strip away all the vendor marketing and ecosystem noise. It boils down to this: How do we create software components for distributed computing that can be easily deployed in the cloud?
当您消除所有供应商营销和生态系统噪声时，云计算的基本挑战实际上并不是那么复杂。它可以归结为：我们如何创建可以轻松部署在云中的分布式计算的软件组件？
This isn’t a new problem, by the way. We’ve seen similar challenges before in the history of computing. Remember CORBA? Yeah, that distributed object standard from the ’90s that tried to solve interoperability between different systems? It was attempting to tackle a similar conceptual challenge, just in a different era with different constraints.
顺便说一下，这不是一个新问题。我们以前在计算历史上都看到了类似的挑战。还记得科尔巴吗？是的，那是试图解决不同系统之间互操作性的90年代分布式对象标准？它试图应对类似的概念挑战，只是在不同的时代具有不同的限制。
When I think about how cloud deployment should work, I imagine something beautifully simple: you write your code, and then you send it “up” to the cloud with as few intermediate steps as possible. Ideally, instantaneously. Write code, deploy code. Done.
当我考虑云部署应该如何工作时，我想象一些简单的东西：您编写代码，然后将其“向上”发送到云中，并尽可能少地中间步骤。理想情况下，即时。写代码，部署代码。完毕。
Notice I’m not talking about testing or security here – those are separate concerns. Having an instantaneous deployment system wouldn’t prevent you from adding subsequent phases of hardening and validation. In fact, it would probably help those processes too, because you’d have a cleaner, more predictable foundation to build upon.
请注意，我不是在这里谈论测试或安全性 - 这些是单独的问题。拥有瞬时部署系统不会阻止您添加随后的硬化和验证阶段。实际上，这可能也会有所帮助，因为您将拥有一个更清洁，更可预测的基础。
What the Ideal World looks like
理想的世界是什么样的
In my ideal world, we’d have systems similar to what already exists for languages like Erlang or Unison: languages that were designed from the ground up with distributed computing in mind. But we’d have this capability available for all programming languages, not just the lucky few.
在我理想的世界中，我们将拥有类似于Erlang或Unison等语言已经存在的系统：从头开始设计的语言，考虑到分布式计算。但是，我们将为所有编程语言提供此功能，而不仅仅是幸运的少数人。
And here’s the kicker: universal components that work across all languages already exist. Look at WASI (WebAssembly System Interface), components built on WebAssembly that provide a platform-independent, efficient format that any language can compile to. This would be my dream solution: write your code in whatever language you prefer, compile your microservices into semantically meaningful components using a platform-independent but efficient format, and deploy them universally.
这是启动器：已经存在所有语言的通用组件。查看WASI（WebAssembly System接口），该组件构建在WebAssembly上，该组件提供了与平台无关，有效的格式，任何语言都可以编译为。这将是我的梦想解决方案：以任何您喜欢的语言编写代码，都使用独立于平台但有效的格式将微服务汇编为具有语义上有意义的组件，并普遍部署它们。
This approach is remarkably similar to what’s being done today with systems like Apache OpenServerless. These platforms actually get it right, focusing on the logical components and their behavior rather than getting bogged down in infrastructure minutiae.
这种方法非常类似于当今的Apache OpenServerless之类的系统。这些平台实际上是正确的，专注于逻辑组件及其行为，而不是在基础架构细节中陷入困境。
The Docker Disaster
Docker灾难
But instead of this elegant vision, what has become the standard for cloud components? Docker.
但是，不是这种优雅的愿景，而是成为云组成部分的标准？Docker。
Let me explain what Docker actually is for those who might not know the gory technical details:
让我解释一下对于那些可能不知道血腥技术细节的人的实际是什么：
Docker is essentially a sandwich of disk images where you can shove absolutely anything, and then these images get executed by running whatever legacy software you’ve crammed in there, regardless of how horrific or inconsistent it might be, with zero behavioral controls.
Docker本质上是一个磁盘图像的三明治，您可以绝对可以推动任何东西，然后通过运行您在那里挤过的任何旧软件，无论其行为控制零多么可怕或不一致，都可以执行这些图像。
Think about that for a moment. We’re building our entire cloud infrastructure around a concept of “component” that is completely undefined. A Docker component is literally “a disk image with whatever random stuff you decided to put inside it!” The only reason this approach gained traction is because it saves upload space compared to creating full virtual machines. That’s it. That’s the revolutionary innovation we’ve built our entire ecosystem around.
想一想。我们正在围绕一个完全不确定的“组件”概念构建整个云基础架构。Docker组件实际上是“一个磁盘图像，您决定将其放入其中的任何随机物品！”这种方法获得吸引力的唯一原因是因为它与创建完整的虚拟机相比节省了上传空间。就是这样。这就是我们建立了整个生态系统的革命性创新。
From this fundamentally broken concept of componentization, we’ve constructed the entire Kubernetes ecosystem, which exists primarily to solve the problem of managing these semantically meaningless horrors by aggregating all possible kinds of digital garbage into something that resembles a functioning system.
从根本上破裂的组件化概念中，我们构建了整个Kubernetes生态系统，这些生态系统主要是为了解决这些语义上毫无意义的恐怖的问题，通过将所有可能的数字垃圾汇总到类似于功能性系统的东西中。
Why Kubernetes is inherently difficult
为什么kubernetes本质上很难
This is precisely why Kubernetes is so notoriously difficult to work with. It’s not difficult because distributed systems are inherently complex (though they are). It’s difficult because Kubernetes is fundamentally an assembler of garbage.
这就是为什么Kubernetes如此难以合作的原因。这并不困难，因为分布式系统本质上是复杂的（尽管它们很复杂）。这很困难，因为Kubernetes从根本上是垃圾的组装商。
Every component in a Kubernetes cluster can violate any rule, consume unlimited memory, crash randomly, loop without control, and it’s entirely up to you to figure out how to handle these problems. There’s no semantic contract, no behavioral guarantees, no meaningful abstraction layer between your application logic and the chaos of whatever random processes are running inside those containers.
Kubernetes群集中的每个组件都可以违反任何规则，消耗无限内存，随机崩溃，无控制的循环，这完全取决于您弄清楚如何解决这些问题。没有语义合同，没有行为保证，应用程序逻辑与这些容器中任何随机过程的混乱之间没有有意义的抽象层。
Deploying a system on Kubernetes is always a nightmare of managing a collection of unhinged components that can explode at any moment for any reason. And we’ve somehow convinced ourselves that this is not only acceptable but represents the pinnacle of modern software engineering.
在Kubernetes上部署系统始终是管理一系列无缘组件的噩梦，这些组件随时都可以随时出于任何原因而爆炸。而且我们以某种方式说服自己，这不仅可以接受，而且代表了现代软件工程的巅峰。
The symptoms of this fundamental architectural problem are everywhere once you start looking. The endless YAML configuration files that nobody really understands. The “Kubernetes experts” who spend their time memorizing arcane incantations rather than solving actual business problems. The conferences where people present complex solutions to problems that shouldn’t exist in the first place.
一旦您开始寻找，这种基本建筑问题的症状无处不在。没人真正理解的无尽YAML配置文件。花费时间记住奥术咒语而不是解决实际业务问题的“ Kubernetes专家”。人们为问题提供复杂的解决方案的会议首先不存在。
We’ve created a cargo cult around Kubernetes, where practitioners perform elaborate rituals (writing extensive Helm charts, configuring service meshes, tuning resource limits) without really understanding why these rituals are necessary or whether they’re actually solving the right problems.
我们在Kubernetes周围创建了一个货物邪教，从业者在其中执行精心制作的仪式（编写广泛的舵图，配置服务网格，调整资源限制），而没有真正理解为什么这些仪式是必要的，或者他们是否真的解决了正确的问题。
The truth is, most of these “solutions” are just band-aids covering up the fundamental issue: we’re trying to build reliable, predictable systems out of components that are inherently unreliable and unpredictable.
事实是，这些“解决方案”中的大多数只是涵盖基本问题的创可贴：我们正在努力从固有不可靠且不可预测的组件中构建可靠，可预测的系统。
Here’s where the “innovation bottleneck” part comes in
这是“创新瓶颈”部分出现的地方
When your deployment platform is this complex and fragile, innovation slows to a crawl. Teams spend more time fighting with Kubernetes configurations than they do building new features or solving customer problems.
当您的部署平台是这种复杂而脆弱的时，创新会减慢爬网。与构建新功能或解决客户问题相比，团队花费更多的时间与Kubernetes配置斗争。
Startups that should be moving fast and breaking things instead spend weeks getting their deployment pipeline working. Enterprise teams create entire “platform engineering” departments whose primary job is to wrestle with the Kubernetes beast. The cognitive load is enormous, and the opportunity cost is staggering.
应该快速移动并破坏事情的初创公司花费数周的时间使部署管道正常工作。企业团队创建了整个“平台工程”部门，其主要工作是与Kubernetes Beast搏斗。认知载荷是巨大的，机会成本令人震惊。
Even worse, this complexity creates a false sense of sophistication. Teams feel like they’re doing “real engineering” because they’re dealing with complicated systems, but they’re actually just managing accidental complexity that shouldn’t exist in the first place.
更糟糕的是，这种复杂性会产生一种错误的复杂感。团队觉得自己正在做“真正的工程”，因为他们正在处理复杂的系统，但实际上他们只是管理不应该存在的意外复杂性。
Lock-in effect?
锁定效果？
Kubernetes has also created a powerful lock-in effect that stifles competition and alternative approaches. Once you’ve invested heavily in Kubernetes expertise, tooling, and infrastructure, it becomes very difficult to consider alternatives, even when those alternatives might be objectively better.
Kubernetes还产生了强大的锁定效果，扼杀了竞争和替代方法。一旦您对Kubernetes的专业知识，工具和基础架构进行了大量投资，即使这些替代方案可能会更好地更好地考虑替代方案，也很难考虑替代方案。
This lock-in effect is particularly insidious because it’s not just technical, it’s cultural and organizational. Companies hire “Kubernetes experts,” attend Kubernetes conferences, and build their engineering culture around Kubernetes concepts. Questioning Kubernetes becomes tantamount to questioning the technical competence of the entire organization.
这种锁定效果特别是阴险的，因为它不仅是技术性的，而且是文化和组织的。公司雇用“ Kubernetes专家”，参加Kubernetes会议，并围绕Kubernetes概念建立工程文化。质疑Kubernetes变得涉及质疑整个组织的技术能力。
While we’re all busy learning the latest Kubernetes best practices and debugging mysterious pod failures, we’re missing out on genuine innovations in distributed computing. Languages and platforms designed for distributed systems from the ground up are being overshadowed by the Kubernetes hype cycle.
尽管我们都忙于学习最新的Kubernetes最佳实践并调试神秘的POD故障，但我们却错过了分布式计算中的真正创新。Kubernetes炒作周期掩盖了为分布式系统设计的语言和平台。
Systems that provide true semantic abstractions for distributed computing – where you can reason about your application logic without getting bogged down in infrastructure details – are being ignored in favor of yet another Kubernetes management tool.
为分布式计算提供真实语义摘要的系统（您可以在不陷入基础架构细节中陷入困境的情况下对应用程序逻辑进行推理），而忽略了另一个Kubernetes管理工具。
The irony is that many of the problems Kubernetes claims to solve have already been solved more elegantly by other approaches. But because everyone’s invested in the Kubernetes ecosystem, these superior solutions remain niche and underexplored.
具有讽刺意味的是，Kubernetes声称要解决的许多问题已经通过其他方法更优雅地解决。但是，由于每个人都投资于Kubernetes生态系统，因此这些优越的解决方案仍然是利基市场，而且没有充满信心。
So what’s the alternative? How do we break free from this cycle of complexity?
那么什么是选择？我们如何摆脱这种复杂性周期？
First, we need to acknowledge that the emperor has no clothes. Kubernetes is not the inevitable result of distributed systems complexity: it’s the result of building an entire ecosystem around a fundamentally flawed abstraction.
首先，我们需要承认皇帝没有衣服。Kubernetes并不是分布式系统复杂性的必然结果：这是围绕根本有缺陷的抽象构建整个生态系统的结果。
Second, we need to invest in better abstractions. WASI and WebAssembly represent one promising direction. Languages like Erlang and platforms like Unison show us what’s possible when distributed computing is baked into the design from the beginning.
其次，我们需要投资于更好的抽象。WASI和WebAssembly代表一个有希望的方向。像Erlang和Unison这样的平台之类的语言向我们展示了分布式计算时的可能性。
Third, we need to resist the urge to add more layers of complexity on top of Kubernetes. Every new “Kubernetes management” tool is just another band-aid on a fundamentally broken system.
第三，我们需要抵制在Kubernetes顶部增加更多复杂性的冲动。每个新的“ Kubernetes Management”工具都是根本破损系统的另一个创可贴。
The uncomfortable truth
不舒服的真理
The most uncomfortable truth about Kubernetes is that it’s successful not because it’s good, but because it’s good enough to solve the immediate problem of “how do we deploy these Docker containers at scale” while being complex enough to create an entire industry of consultants, conferences, and training courses around it.
关于Kubernetes的最不舒服的事实是，它的成功不是因为它很好，而是因为它足以解决“我们如何大规模部署这些Docker容器”的直接问题，同时足够复杂，可以创建整个顾问，会议和培训课程的整个行业。
There’s a perverse incentive structure where the complexity of Kubernetes actually benefits many players in the ecosystem. Tool vendors can sell “Kubernetes management” solutions. Consultants can charge premium rates for Kubernetes expertise. Conference organizers have an endless supply of complex topics to fill their agendas.
有一个不正当的激励措施结构，即库伯尼犬的复杂性实际上使生态系统中的许多参与者受益。工具供应商可以出售“ Kubernetes Management”解决方案。顾问可以为Kubernetes专业知识收取保费费率。会议组织者有无穷无尽的复杂主题来填补议程。
But this success comes at the cost of actual innovation. We’re optimizing for the wrong things, and we’re all paying the price in terms of developer productivity, system reliability, and the pace of genuine technological progress.
但是这一成功是以实际创新为代价的。我们正在为错误的事情进行优化，并且我们都在开发人员生产率，系统可靠性和真正技术进步的步伐方面付出了代价。
Breaking free
断裂
I know this critique won’t be popular in certain circles. Kubernetes has a lot of mindshare, a lot of investment, and a lot of smart people working on it. But sometimes the hardest thing to do is admit that we’ve been going down the wrong path, no matter how much we’ve already invested in that path.
我知道这种批评在某些圈子中不会流行。Kubernetes有很多思想，大量的投资和许多聪明的人从事它。但是有时候，最难做的是承认，无论我们已经在这一道路上投入了多少，我们一直走错了道路。
The cloud computing revolution promised us simplicity, scalability, and rapid iteration. Instead, Kubernetes has given us complexity, fragility, and endless configuration management. We can do better, but only if we’re willing to acknowledge the fundamental problems with our current approach.
云计算革命向我们保证了我们的简单性，可扩展性和快速迭代。相反，Kubernetes为我们提供了复杂性，脆弱性和无尽的配置管理。我们可以做得更好，但是前提是我们愿意承认当前方法的基本问题。
The future of cloud computing shouldn’t be about managing the chaos of arbitrary containers. It should be about building systems where good behavior is the default, where semantic guarantees are built in, and where developers can focus on solving real problems instead of wrestling with deployment complexity.
云计算的未来不应是管理任意容器的混乱。它应该与建立良好行为是默认行为，内置语义保证的构建系统有关，并且开发人员可以专注于解决实际问题，而不是与部署复杂性搏斗。
Until we’re ready to have that conversation honestly, Kubernetes will continue to be the colossal innovation bottleneck that it is today, dressed up in the clothes of progress and sold as the solution to problems it largely created in the first place.
直到我们准备好诚实地进行对话之前，Kubernetes将继续成为今天的巨大创新瓶颈，穿着进步的衣服打扮，并作为解决该问题的解决方案首先创造的问题。
