5 ms·
It is hard not to build this impression of containers. Worse, it seems that the docker image format is massive compared to what most war files were like. This
by taeric 8y ago
It is hard not to build this impression of containers. Worse, it seems that the docker image format is massive compared to what most war files were like. This is annoying not just in terms of raw bytes to move around, but in taking stock of what is getting moved around.
My team originally pitched how docker solved much of the dependency upgrade management by having layers for each major set of dependencies. That ignored the fact that upgrading a layer is not really something you do.
So, then you can go around the path of coordinating many containers communicating with each other. That works, but in that world, things really don't seem any easier than the earlier alternatives. Harder, in many ways.
Don't get me wrong, the momentum and raw money being put into containers certainly paints it as the future. It just feels like lying to say that they have even come close to parity with what we were capable of not that long ago.
- xj9 8y agothe linux world is slowly (and badly) recreating technology that has existed in FreeBSD and Solaris/Illumos for decades.
- taeric 8y agoBe fair here. The software world is slowly recreating technology. Being even more fair, they do often add to it. Usually UX capabilities, but sometimes full on features. Yes, often the features require more resources than were available before. Such that previous versions couldn't have offered some of these things. That said, it is not limited to any one set of our industry. It is likely not even limited to our industry.
- redbeard0x0a 8y agoSoftware getting recreated, sometimes without the security promises (linux containers as they started vs. solaris zones) the previous solution had. To be fair, Google didn't really need the security in linux containers, they didn't run multi-tenant workloads, so it wasn't their top concern when submitting code to the linux kernel... We like building new things, from different angles, but in the end it seems like everything cycles through the same ideas.
- taeric 8y agoCompletely agreed. It is hilarious because we all preach "don't reinvent the wheel" at the same time that our interviews are basically "can you implement this ridiculously low level wheel" on top of "come here where we are simply using the latest rims!" :)
- tomsthumb 8y agoWhich technologies were those? I’m only vaguely familiar with FreeBSD, and not at all with Solaris.
- devonkim 8y agoFreeBSD has had jails and Solaris has had zones (with a Linux compatible zone as well aka branded zone). Given Illumos takes a lot of its roots from Solaris, it also has LX branded zones.
- grapeli23 8y agoYou probably never heard or used - Linux VServer. Available from the later version of the 2.4 kernel. https://en.wikipedia.org/wiki/Linux-VServer https://en.wikipedia.org/wiki/Linux-VServer
- xj9 8y ago> 2008 FreeBSD jails date from 2000 Solaris zones date from 2004 https://us-east.manta.joyent.com/bcantrill/public/ppwl-cantrill-jails.pdf https://us-east.manta.joyent.com/bcantrill/public/ppwl-cantr... https://us-east.manta.joyent.com/bcantrill/public/ppwl-cantrill-zones.pdf https://us-east.manta.joyent.com/bcantrill/public/ppwl-cantr...
- grapeli23 8y ago2003 http://linux-vserver.org/Overview#History http://linux-vserver.org/Overview#History In the Linux distribution that I used (PLD), the first vserver support took place in january 2004. https://github.com/pld-linux/kernel/commit/5be58c1bcc5568676a75dd9f7096827bfcde08e8 https://github.com/pld-linux/kernel/commit/5be58c1bcc5568676... Maybe a little earlier because the util-vserver showed in Nov 2003. https://github.com/pld-linux/util-vserver/commit/c4036d6e748808e07671ba402b3fe7ca027db82a https://github.com/pld-linux/util-vserver/commit/c4036d6e748...
- deleted 8y ago[deleted]
- pjmlp 8y agoAnd HP-UX/Tru64 before them. We were deploying into HP Vaults in 2000.
- ecnahc515 8y agoYeah, except even jails has gaps, like for example; shared memory isn't jailed.
- bsenftner 8y agoThey are the shit tech that will be abandoned with the next fad. They are a huge boondoggle, solely for the immature leads who have not been coding for decades and know better. This industry is filled with stupid fucks that don't know tech history.
- toomuchtodo 8y agoYou have a point about hype, tech cycles, and solutions being pushed out of ignorance vs tech superiority if you change the language to be more civil.
- bsenftner 8y agoYou're right.
- jrs95 8y agoAlthough it's a bad point without any concrete examples. Without that, it just seems like a baseless emotional reaction to not liking something new. I might even be inclined to agree if there was a bit more detail given.
- toomuchtodo 8y agoContainers are a solution looking for a problem, used more for organizational reasons than technical. Disclaimer: Infra/DevOps engineer previously, 20 years total in tech
- jrs95 8y agoI hear things like this a lot but I never hear how you could accomplish the same things as Kubernetes (or any other orchestrator) without containers. Even if there were good solutions available for this, and the only advantage of containers was an organizational advantage rather than a technical one, I think that would still be a win.
- 8y ago
- dnomad 8y agoExactly. Docker files are worse than war files in pretty much every way. The economics are interesting though. Computing resources are super cheap and getting more cheap everyday. (Well except for RAM!) The waste produced by containers means says, yeah, give each application its own app server. Its own web server, its own JDBC driver, even its own JDK. We'll throw it all on the cloud and run it for a few cents each hour. The problem is that testing isn't cheap. This is where microservices and containers and the all this craziness will fall down. Now you've got dozens and dozens of applications all running with their own application servers, JDBC drivers, and their own JDK. This is a combinatoric explosion in your testing surface. The true value of the application server approach is that it forced applications to conform to a clear contract. Once your application conformed to this contract it could be thrown over the wall into a full-time ops organization that could transparently deploy, monitor and manage the app. The container madness will come to an end. People will realize that giving developers the keys to the kingdom and total freedom over their application is a terrible idea. (And smart developers don't want total freedom.) What will emerge will be something much more interesting: a hybrid approach where applications can be bundled into into artifacts that fully express their dependencies and containers can be annotated in a way that fully express their capabilities. Containers provide isolation and immutable infrastructure and this is good. Appservers provide standardization, specialization and separation of responsibilities and this is also good. There's no reason why we can't enjoy both.
- kinghajj 8y agoNothing prevents one from having a container with many WAR files, so that there's only a single JVM for multiple applications.
- dnomad 8y agoThe entire exercise is about expressing dependencies. (The real third hard problem in computer science. Only idiots fall for off-by-1 errors.) Containers are one way to force an application to explicitly declare all of its dependencies. The problem is the application then also bundles those dependencies. There's not much room for control or intermediation. Developers have total freedom to do all sorts of wackiness. (And oh the wackiness I've seen in containers. When the cat is away...) What's needed is a richer (and much more compact) mechanism for applications to express all their dependencies. Another way to understand the issue to understand the underlying economics at work here. Container economics proposes that computing resources are so cheap that, sure, let the developers go crazy and do whatever they want. But those same developers must be on the hook for all operational concerns hence "DevOps." And this will scale until one day you look around and you realize that anarchy never works, not even a little bit. Now there's a lot of room to fall here. RedHat is in the business of selling compute and storage resources. It's not clear that even if they could make their products more efficient they would. But as long as compute resources are cheap and getting cheaper you can let people go wild and RedHat will make a lot of money and everybody will be happy. For an organization the true costs will emerge in a very subtle manner: the productivity of the developers (already hard to measure) will ultimately fall. That's because instead of actually solving actual business problems their devs are deploying dozens and dozens of polyglot microservices and trying to figure out why on earth microservice #28 that Bob, who left the company a year ago, decided to write in a version of lisp that he invented crashes every day at noon. But hey, at least Kubernetes makes it easy to deploy everything!
- dionian 8y agoSo just reuse the common layers and only have your WAR file layer changing
- taeric 8y agoThe problem is when there is a vulnerability in some part of an earlier layer. You have to rebuild the entire stack. I honestly don't think this is necessarily a terrible thing. But, the idea that your common layers are stable is a dangerously bad assumption.
- cpuguy83 8y agoWhat are you defining as stable? Never changing? That's not something that should even hinted at. The fact that you can login to a VM and update a package does not make the system stable either (and of course you can actually do this with running containers as well). Add to that you still need to restart running applications to take advantage of the package update (assuming the packages is a shared lib). Meanwhile you can push new base images, automatically trigger rebuilds and roll out the update when ready.
- taeric 8y agoI suspect we mostly agree with each other. My experience with folks in containers so far has proven to be that this is often hoped, though. Specifically, we had devs talking about how we wouldn't have to worry about system patching anymore, because the containers would take care of that. With no answer for how we trace versions and patches through our systems. If you are already tooled enough such that you can completely redeploy a full stack easily without worrying about some in place modifications, the difference between a VM and a container are relatively minimal, all told. Especially since you have to be ready to pull down the host of the containers anyway.
- cpuguy83 8y agoThe main difference is the container is focused on an application and a VM is focused on a machine. Generally the patching problem can be solved with image scanning, of which there are tools out there to deal with this, both FLOSS and pay for.