shoe-string-server VS swarmpit

I have a very similar system[1] for my personal projects, only I use GitHub actions to push a docker image to ECR and a commit to a config repo bumping the tag. I then have a cronjob to pull the config repo and reconcile using docker compose.

I wouldn't use it for serious stuff, but it's been working great for my random personal projects (biggest gap is if something crashes it'll stay crashed until manual intervention currently)

- [1] https://github.com/mnahkies/shoe-string-server/pull/2

For my personal stuff that doesn't get any traffic I cobbled together some scripts to manage containers / SSL here https://github.com/mnahkies/shoe-string-server

I don't think I ever got around to making it self healing if a container dies, but it does support gitops style deployments through a cronjob / conf repo similar to argocd

It's been running happily on a <$10 / month aws lightsail instance for a few years now, though tbh I'd still reach for k8s for anything serious

Interestingly this seems like a pretty popular problem to solve.

I made a similar thing recently as well, although with the goal to handle ingress and monitoring out the box as well, whilst still able to run comfortably on a small box.

I took a fairly similar approach, leveraging docker-compose files, and using a single data directory for ease of backup (although it's on my to-do list to split out conf/data).

If there was a way to get a truly slim and easy to setup k8s compatible environment I'd probably prefer that, but I couldn't find anything that wouldn't eat most of my small servers ram

https://github.com/mnahkies/shoe-string-server if you're interested

So I need to setup prometheus, granfana, node exporter, and cadvisor before running this? All of the above give me everything I need to monitor a swarmcluster. And if I want multi-user access to the graphs, I’d configure auth in Grafana.

Further, if I were to monitor Swarm without the Prom+Grafana stack, I’d be looking at:

https://github.com/swarmpit/swarmpit

What is the value-add of Storm?

And then also look at Swarmpit https://github.com/swarmpit/swarmpit. It was last updated Aug 28, 2020 as well, so I don't know how active it is, but I also used it for a while before sticking with Portainer ultimately.

Kubernetes is a bit overkill. For my homegrown usage i use docker swarm. And use https://swarmpit.io to manage it

Specific to swarm but it might help soneone in a way https://github.com/swarmpit/swarmpit

> There is gap in the market between VM oriented simple deployments and kubernetes based setup.

In my experience, there are actually two platforms that do this pretty well.

First, there's Docker Swarm ( https://docs.docker.com/engine/swarm/ ) - it comes preinstalled with Docker, can handle either single machine deployments or clusters, even multi-master deployments. Furthermore, it just adds a few values to Docker Compose YAML format ( https://docs.docker.com/compose/compose-file/compose-file-v3... ) , so it's incredibly easy to launch containers with it. And there are lovely web interfaces, such as Portainer ( https://www.portainer.io/ ) or Swarmpit ( https://swarmpit.io/ ) for simpler management.

Secondly, there's also Hashicorp Nomad ( https://www.nomadproject.io/ ) - it's a single executable package, which allows similar setups to Docker Swarm, integrates nicely with service meshes like Consul ( https://www.consul.io/ ), and also allows non-containerized deployments to be managed, such as Java applications and others ( https://www.nomadproject.io/docs/drivers ). The only serious downsides is having to use the HCL DSL ( https://github.com/hashicorp/hcl ) and their web UI being read only in the last versions that i checked.

There are also some other tools, like CapRover ( https://caprover.com/ ) available, but many of those use Docker Swarm under the hood and i personally haven't used them. Of course, if you still want Kubernetes but implemented in a slightly simpler way, then there's also the Rancher K3s project ( https://k3s.io/ ) which packages the core of Kubernetes into a smaller executable and uses SQLite by default for storage, if i recall correctly. I've used it briefly and the resource usage was indeed far more reasonable than that of full Kubernetes clusters (like RKE).

I believer Portainer and Swarmpit would have this capabilties https://www.portainer.io/ https://github.com/swarmpit/swarmpit