One big DB will be a single point of failure. You will not benefit from much more speed, the only thing which is "easier" is backup.

I use different DBs for different stacks. If one hangs up or messed up completly, it won't affect others

I take the latter approach -- a single PostgreSQL database service for all other containers to use. That allows me to concentrate memory/CPU to a single service and optimize for that. I've found that a single database service uses less total resources (especially memory) than running separate DB stacks for each service.

I don't wanna go all 90s forum user here, but I think this is the 5th post asking this. Maybe just have a look first if this has been answered already.

On topic: just use a new db with each service.

My recommendation, if practical, is a single, potentially containerized DB server that is backed by storage that provides high availability and redundancy. This is supposing that you are using the same sort of DB (ex SQL, NoSQL, etc) and that you are targeting a smallish number of services that are on-premise.

My reasoning here is that you can treat the DB server effectively as a storage API service and run it via some orchestration service like K8S. This lets you offload your DB stability and data integrity to the FS and/or other low-level stuff that is simple to configure once and only dirty about when hardware fails. This in turn greatly reduces DB server configuration and deployment as well as treat them like livestock, not pets.

Now, if you are using a public cloud provider, my view changes slightly. Generally, I'd suggest offloading the DB to a provided service that is compatible with a FOSS alternative so that you can avoid vendor lock-in. This means that you get the HA, etc without having to worry about maintenance and configuration overhead. Just be aware of cost modeling - it's easy to run up large bills.

I'll usually centralized them. Use less resources than running them separately, and makes backup easier.

Multiple. They might need different versions of the database server, they might need to be scaled differently, they might need to be backed up at different cadences, they might need to be moved to different servers…. Etc.

The small marginal resource reduction is just not worth it.

Separate DB containers for each service. Easier, more secure, and less messy. The overhead impact is trivial.

1. If a service supports sqlite, I often will use that option. It provides everything a self-hoster needs from a DB with basically no operational overhead.
2. If I do need a proper RDBMS (because the software I'm using doesn't support sqlite), I'm going to use...
   1. A single Postgres container.
   2. Configured with multiple logical "databases" (the container for schemas and tables), one DB for each app connecting.

I do this because I'm always memory constrained and the rdbms is generally the most memory-hungry part of any software stack. By sharing one db-process across all the apps that need it I get the most out of my db cache memory, etc. And by using multiple logical db's, I get good separation between my apps, and they're straightforward to migrate to a truly isolated physical DB if needed... but that's never been needed.

I do a separate container for each service that requires a db. It's pretty baked into my backup strategy at this point where the script I wrote references environment variables for dumps in a way that I don't have to update it for every new service I deploy.

If the container name has -dbm on the end it's MySQL, -dbp is postgres, and -dbs would be SQLite if it needed its own containers. The suffix triggers the appropriate backup command that pulls the user, password, and db name from environment variables in the container.

I'm not too concerned about system overhead, but I'm debating doing a single container for each db type just to do it, but I also like not having a single point of failure for all my services (I even run different VMs to keep stable services from being impacted by me testing random stuff out.)