EDIT the missing content..:
I mean currently it mostly is for the big users. There aren't too much things for "small" users. The big things like kubernetes, etc are really hard to configure / maintain, etc.
I mean it's easier to maintain ansible / puppet / chef / etc... - scripts than maintaining a real "docker" environment. even looking at deis, flynn, openshift its not just run "this, upgrade with this".
after you setup the hole thing you need to create huge buildpack scripts or Dockerfiles or kubernetes configs or whatever.
you just needed process isolation, now you build a infrastructure on top of a infrastructure.
The direction where it is going is to create an "internet operating system" you upload your application and don't care on which server it is running.
Currently that above problem has not been solved yet, and what we have is just bunch of tools to put them together and DIY.
The real power of this will come, once cloud providers will allow you to simply upload the images without having to build that infrastructure yourself.
I think you're right to fall back to ansible / puppet / chef, because this technology is simply not ready yet.
This is especially true if you're using public cloud (and while you can make it work in AWS, it will cost you more; both due to amount of effort, but also due to overhead imposed by it. Remember, AWS still charges you by VM).
There might be some benefits of using it right now when you have your own datacenter with physical machines. It could provide costs savings, compared to running your apps on dedicated physical servers or even using VMs.
as said the only thing gain for docker would be process isolation, so it should be really really awkward simple and useful on low end hardware. (as the other solution already does) and getting process isolation with cgroups isn't too hard on newer kernels. (# systemctl set-property httpd.service CPUShares=500 MemoryLimit=500M)
so what the product needs to have:
- process isolation
- easy configuration
- configure the os/software and update it easily
- nothing more than a bunch of lines per project (no dockerfile frickling)
- binary / git rollouts
If you're well invested in puppet, using puppet is going to be easier because you know it. You can happily use docker with puppet. Stop puppet from installing $APP and instead use it to docker pull && docker run $APP.
This means the logic for building your application has obviously moved to the Dockerfile. You cannot currently get rid of this logic, only hide it in abstractions. I prefer it living in the apps repo as it's a nice seperation of concerns, but you obviously would prefer it to be magic, which you can have but at the price of versatility.
If you are able write code to build and deploy apps, then moving over to using docker should be pretty trivial for you. However, I actually see docker as a replaceable part, whilst kubernetes might actually be here to stay.
* shared folders to persist necessary files. and thus volumes. and a few years later distributed volumes.
* not just isolate a process, but all its dependencies as well. no point in having a shared .so file which everybody can change, while just a single process is isolated. and thus a whole sandboxed container.
* and then deal with the size of a full sandbox, until you need some way to share unchanged files. and thus images and layers.
* and so on and so on.
big things always start small. at least in docker's case they did start small, and they're still small and lean individual projects. feel free not to use docker compose or anything else.
The project is only month and a half long so if you want I can talk you through privately
My favourite is Cloud Foundry, because I've worked on it and I trust the way it's built.
Here's how I deploy an app: