2 ms·
A lot of your concerns are around ops, and I agree that docker has a pretty immature approach there. That said, most of the sysadmin world has the same problem.
by contingencies 13y ago
A lot of your concerns are around ops, and I agree that docker has a pretty immature approach there. That said, most of the sysadmin world has the same problem. Hell, people still do things manually or with PFCTs (post-facto configuration tinkerers) ... without prior testing!
Cfengine delivering a single change on a single file to a dynamically-assigned set of nodes is a lot faster, lower overhead, and direct than deploying a Docker change.
To container-based architectures' credit, cfengine-style changes are not as 'known', since there are aspects of the environments that may differ. Containers can be 100% accurately cloned so significant testing can be performed before deployment. Of course, you could test with cfengine as well, it's just that when you attempt to set up nodes to do the tests against you'll suddenly realize the utility of container-based virt ;)
- peterwwillis 13y agoContainers can be 100% accurately cloned so significant testing can be performed before deployment. This has been the catch-22 i've had problems explaining, so bear with me here. Your docker container and my cfengine change are exactly the same thing in terms of testing and guarantees of sameness. So, you have a Docker, and you hand-built it to an exact specification, and made an image that does a specific thing. You ship that image to 1000 nodes and it works "exactly the same" across all of them. So, I have Cfengine, and I hand-configured it to an exact specification of operations, and made a config file that does a specific thing. I ship that config to 1000 nodes and it works exactly the same across all of them. Why did they both end up giving me exactly what I expected? Because I controlled the input and the structure of the files to exactly my specifications, and nothing changed in those files once it was copied to the nodes, so they worked exactly as I expected. We can also assume I had no other dependencies for either to work. (The Cfengine dependencies were the cfengine binary, which we can ensure is the same version across all hosts pretty easily. The Docker version, and the whole "ecosystem" of docker tools, is similar to enforce, though the much wider range of dependencies will make it much harder to support the same ones on all platforms, which is where we have to start using a unified platform, which is where the whole "run it anywhere on anything" bullshit becomes painfully unrealistic) Uh-oh, here comes trouble! A developer comes over and wants 10 of the 1000 nodes to work a little differently. OK, we make a config file that Docker will read to configure the service a little different. Separately, we can make Cfengine read a similar config file that tells it how to configure the node differently. We ship the config file off to the 10 nodes, and Docker/Cfengine reads it in and changes its operations. All of a sudden we have unexpected behavior due to the new instructions in the config file. One hundredth of our hosts are doing something different and we have to now account for that in anything else that happens in the future. (That is not some drawback of some technology, btw; that is called "I have a real network where things work differently across it"). The practical differences between these two is that the Cfengine change can be tested and applied quicker than a Docker, it doesn't force you to choose how to update your application ("am I updating the image? am I adding an image? am I changing the Dockerfile? am I changing the config? should I restart the docker or the service? do I have to reconfigure the autodetecting whatsit?" etc), and instead of hiding changes in a "Dockerfile" which is only parsed at build time, it keeps changes forefront in a configuration parsed at run time. You can make either one work just as reliably as the other. But one is a hell of a lot clunkier to get working in all cases than the other. Also, i'm comparing a configuration management tool to a chroot environment network transfer tool, so take all of this with a grain of salt.
- contingencies 13y agoYes, it's true you can achieve an equivalent output on multiple hosts either through container based (or some other form of virtualization), or through a PFCT like cfengine. As the perl motto goes, TMTOWTDI. However, one could posit that being ~absolute (given some base assumption of host kernel features), storable and self-contained, a virtualized image (container-based or otherwise) is far more 'complete' a unit to the unskilled random (ie. most users) than a series of steps (OS setup, some change, some other change) performed with a PFCT. That's pretty subjective, though. Uh-oh, here comes trouble! A developer comes over and wants 10 of the 1000 nodes to work a little differently. In a formalistic and most desirable case, the prescribed node changes should be specified, versioned, documented and pushed. By the developer. With no input from systems administrators or operations people. The best way to do this is usually to define it holistically. Your approach emphasizes the speed of cowboy modification of running machines, whereas a formalistic (and continuous deployment ready) approach emphasizes the security, identifiability and repeatability of instituting the same environment through a standardized process. Both have their benefits, but if the latter is automated it shouldn't be any slower and would still offer benefits over the primarily manually driven PFCT-based ad-hoc change style approach you seem to be championing. Hate to put my finger on it, but an example would be that your salary and/or availability is no longer required. All of a sudden we have unexpected behavior due to the new instructions in the config file. One hundredth of our hosts are doing something different and we have to now account for that in anything else that happens in the future. That's just the point. By having a known entity that is versioned and self contained you don't have these issues. By making manual, ad-hoc changes with a post-facto configuration tinkerer (PFCT) like cfengine, you are out on a limb. The practical differences between these two is that the Cfengine change can be tested and applied quicker than a Docker Containers are very fast. I don't think you can make this argument without citation to numbers, nor do I think it's often relevant as speed of deployment, within certain boundaries, is rarely a bottleneck. it doesn't force you to choose how to update your application ("am I updating the image? am I adding an image? am I changing the Dockerfile? am I changing the config? should I restart the docker or the service? do I have to reconfigure the autodetecting whatsit?" etc) A formalistic release process that incorporate unit testing and the provision of test infrastructure, particularly that for systems including multiple, versioned services that must operate in tandem, requires some overhead. This overhead is about enforcing segregation between developer output and (automated) operations concerns to support continuous integration and continuous deployment. I'd suggest that right now we're going to see this same sort of issue turn up regardless of how we choose to manage services (except manually, in an ad-hoc, error-prone, oldschool, cowboy style fashion), and in future we're going to see less and less systems administrators performing manual processes because some automated segregation mechanism or other will become popular enough to reduce operational demand in many companies for that skillset. Quite separately to the above, I agree that docker fails to provide much of a meaningful feature set in this area, and that docker files might not be ideal. However, something will come along and fill in the gaps, eventually. Probably incorporating corosync/pacemaker or other, proven, prescriptive, cluster engines with self-healing / high availability features that rely upon continuous deployment of well segmented and versioned service instances for their very feasibility.