s6-overlay

If all you need is init (and not a process supervisor), docker comes with one called 'tini' built in. All you have to do is supply `--init` to the `docker run` command. Or use `init: true` in your docker-compose.yaml. As far as a different process supervisor, I'm not sure. I've used supervisord and agree it's kind of awkward. I have heard of these but don't know much about them: https://smarden.org/runit/ https://github.com/nicolas-van/multirun https://github.com/just-containers/s6-overlay

I wouldn't use this if I were you. The last release was over 5 years ago, and there are multiple issues with the code - for instance, you can't even build it anymore if you're on CMake v4+. Basically, this project has been abandoned, and since you can no longer build it from source, you'd have to use the 5+ yr old binaries - which isn't advisable, especially in a production environment. A better, actively-maintained alternative, is S6-overlay: https://github.com/just-containers/s6-overlay

This is well thought-out and quite well documented: https://github.com/just-containers/s6-overlay There's a huge community https://www.linuxserver.io/ for people building "home server" containers that all use the s6-overlay, hundreds of examples there. They have a lot of tutorials and a very busy Discord, Reddit, etc with all levels of experience from container developers to people who don't program and are just getting into Docker. I run a bunch of these containers myself and am pretty happy with how adaptable they are.

This has worked pretty well for me both for service control and pre-execution environment setup : https://github.com/just-containers/s6-overlay There is also good old supervisord, but I haven't personally used it in containers yet. https://docs.docker.com/config/containers/multi-service_cont...

I see. Would it be possible to make those services write to an object store or a database instead? To me, that seems much more container-compatible. However, have a look at https://github.com/just-containers/s6-overlay – I think it can do what you want.

Used s6-overlay[1] to start a lot daemons in a docker-image for demo purposes - postgres, tomcat, mysql, php-fpm, apache (don't ask why ;) - s6 worked really well and was reliable and stable - I enjoyed it very much. It was also possible to reliable pass SIGTERM to the daemons in the image for clean shutdown and it was easily possible to configure logging to stdout with a prefix. Modelling dependencies (waiting on database before starting app etc.pp) is possible via shell-scripts. It's super flexible but out of the box it's more like a collection of powerful tools not a complete package - but that's good. It's in the tradition of djb daemontools and is very unix - as in doesn't talk a lot and you better know how each part works but - and that's really cool - it's modular and simple and once you get a grip on it you can easily reason about

I think "1 container = 1 process" is a common misconception. There should be a separation of concerns, but there's no reason to go to extremes where it doesn't make sense. S6-overlay people lay it out pretty neat https://github.com/just-containers/s6-overlay#the-docker-way

"Docker is easy from a basic usage standpoint like most tutorials are" This applies to basically any software or tooling once you get away from the initial tutorials. They wouldn't be tutorials if they covered all sorts of specific use cases particular to your own situation. "The hard part is when you start configuring and configuring to your own requirements. What baseimage should you use? How about logging?" Either the same distro you would use on a bespoke server, or you can optimize with alpine or scratch. Logging can be as simple or complicated as you want it to be, regardless if you use docker or not. "How about PID 1 problem?" We use s6-overlay [0] to manage this. When a service dies, a script gets executed, giving us control over how to handle it. "How about SSH?" For us, we use ansible to provision/set up kubernetes with ssh keys

"Setting up a systemd unit file (it's not even a script) doesn't even come close to the complexity of wrapping, maintaining, and potentially orchestrating software within containers." I find that the complexity of managing containers is overstated. It does have costs, but the benefits of docker and containerization in general outweigh those costs. Kubernetes is significantly more complicated and is not always a good choice depending on the use case. "like systemd?" I find that systemd tries to do far too much for our needs, namely for just managing services in a container. Our images have their services manged by s6-overlay [0], but there are multiple init systems one can use. I do not see the benefit of systemd over i.e. s6 or runit, but that is tangential to this discussion. [0]: https://github.com/just-containers/s6-overlay

s6-overlay [1] is also a popular choice for Alpine-based containers. [1] https://github.com/just-containers/s6-overlay

Another alternative, for what it's worth: https://github.com/rciorba/pidunu I've created an Ubuntu PPA packaging of it (https://launchpad.net/~danieldent/+archive/ubuntu/pidunu) and you can see an example of it in use at: https://github.com/DanielDent/docker-powerdns For situations involving multiple processes, there's also https://github.com/just-containers/s6-overlay Example use: https://github.com/DanielDent/docker-nginx-ssl-proxy (automated Let's Encrypt SSL front-end)

s6 and s6-overlay were also created with the same goal: https://github.com/just-containers/s6-overlay I use it in my Alpine containers.

My favourite is Alpine Linux with s6-overlay: https://github.com/just-containers/s6-overlay