How To Give A Service Two Volumes Docker Swarm

How to Limit Resources for Docker Swarm Services

Start controlling the resources consumptions of your Docker services and containers

On Linux systems, the OOM killer (Out of memory), will kill any process that is trying to eat resource, such every bit RAM, more than the resources available to the host or assigned to the process.

This behavior could have very dangerous effects on running services, not just in production environments but also for staging and testing environments, only because this means that the services will be down due to a need for more than resources.

Some other drawback of this behavior is that if a service is immune to consume all resources on the host, there is a chance that it will touch on other services running on the same host.

The OMM killer process is watching all processes or services running on Linux systems including Docker daemon and containers.

It is possible to mitigate the take a chance of having i service or process consuming all node resource and affecting other services on the same host by defining resource constrains on the Docker daemon and the services.

With this thought, both the Docker daemon and the Docker containers will accept their own limits. The OMM killer will respect these limits and it will kill the processes when they exceed their limits.

While it is too possible to limit resources for the Docker run time according to the official docs, I will focus on setting resource limits on the individual Docker Swarm services in this mail.

Docker Compose provides two methods to constrain and limit the resource assigned for each of the individual Swarm services and containers. Below is a brief description of these methods.

Reservations

This method will reserve the assigned amount of resource to the Docker tasks during the creation fourth dimension. This means that, in instance you have a host with sixteen GB of RAM and yous assigned 1GB per service job, then you lot will only be able to run at max 16 tasks on that host.

If you try to deploy or scale services on that host to more sixteen tasks, all the new tasks will exist rejected and no new containers will be created considering there are no available resources on the host. This will be the case even if the xvi running containers are just consuming 5 GB.

The reason backside this behavior is that Docker volition reserve ane GB of RAM for each task at the scheduled time which can not exist used past any other procedure on the host.

The values of the limits of the reservation should be as small every bit possible to guarantee that the service volition be able to start and run as expected on the scheduled host.

On the other hand, the reservation values should non cake unneeded resources on the host and bear on the scheduling of other services on the Docker Swarm cluster.

For instance, it is not recommended to ready the reservation value to 5 GB for a service that consumes 500 MB on average. It is obvious in this example that we are wasting the host resources past locking them to a specific service.

Limit

This method sets the upper limit for Docker services on individual bases.

Setting this limit for all services will guarantee that there is no service or container that can exceed its own resource limit and consume nearly of the resource on the host and, as a result, affect the performance of other services.

According to the Docker Compose reference, both cpu and memory resources constraints tin can be fix for the individual services in the post-obit way:

            version: "three.seven"
services:
              redis:
              prototype: redis:alpine
              deploy:
              resources:
              limits:
              cpus: '0.50'
              retentiveness: 50M
              reservations:
              cpus: '0.25'
              memory: 20M

Conclusion

Setting resource limits for Swarm services can help in isolating the Swarm services from each other from a resources point of view. And as a result, no services will be able to dominate all the resources on the host server.