3 ms·
Containers may solve some problems, but they're hardly the only solution and the others seem (note: personal bias) simpler to me. > common baseline "Here is t
by yjftsjthsd-h 9y ago
Containers may solve some problems, but they're hardly the only solution and the others seem (note: personal bias) simpler to me.
> common baseline
"Here is the standard image with standard packages; if you need something else, add it to Chef/Ansible/whatever-we-use"
> responsibility boundary
"Ah, this binary is in /opt/$COMPANY - go ask the devs why it's broken"
> which is identical
So use configuration management (Chef, Ansible, whatever) for the system and tarballs/packages for your stuff, rather than shipping whole system images per-project?
- acdha 9y agoFirst, this is engineering so there's no right answer for everyone. If deploying things using the configuration management tool of your choice works for your project and staffing, it's the right choice. Here are some complications for the traditional approach you mentioned: 1. Containers provide a standard interface for managing things in any language: that means you don't have to know that this Java team used Tomcat, someone else used Jetty, the Python apps use mod_wsgi or gunicorn depending on when they were written, etc. Yes, Chef/Ansible/etc. can coordinate that too but you have to maintain conventions for editing shared configuration, permissions, storage, firewall ports, dealing with religious arguments about systemd, etc. That's especially true if you're using vendor or open-source apps where it's really nice not to have to spend time repackaging something where someone at Oracle, Atlassian, etc. use the LSB docs as rolling paper rather than reading material. Again, having done it for years I'm not saying this cannot be done but it's refreshing not to ever have a talk about user IDs, using a sane config .d layout on RHEL, etc. again. That brings me to: 2. Coordinating changes or updates: again, yes, it's always possible any way you choose to do it but it's really nice not to have to maintain changes in multiple branches for teams at various stages of upgrading, deal with special cases, etc. Shoveling everything into a container means that the only team which deals with those questions is the one best equipped to answer them. That's especially nice when the problem is something like upgrading a common distribution package and it'd take a non-trivial amount of time versus no time to answer the question of whether your backport will break something else used somewhere in your company. 3. This is similar: “Ah, this binary is in /opt/$COMPANY - go ask the devs why it's broken”. In simple cases, yes, that's easy but once it gets more complicated — “this gets slow every Tuesday night”, “we're getting sporadic disk full errors”, etc. — it's really nice to have an inside/outside division which is consistent across every system and every project. Following the LSB rules gets you a lot but that's not universally followed so you're going to have to spend time on exceptions, arguing with vendors, or getting upstream open source projects patched. Again, that's all valid work but some times you don't have the time to spare for.
- cat199 9y ago> not to ever have a talk about user IDs, using a sane config .d layout on RHEL, etc. again until you have to maintain/debug/etc N^N combinations/branches of common code used within the different self produced containers to accommodate all of this 'freedom'...
- acdha 9y agoCould you explain the scenario you have in mind? If you're having trouble maintaining convention across teams producing different shared components, that seems likely to cause problems no matter how you end up deploying things. (This is similar to the argument for containers with developers who aren't great sysadmins: they're usually making changes anyway and this way they don't have root on the host, etc.)