Introduced in Salt version
2017.7.0 it is now possible to run select states
in parallel. This is accomplished very easily by adding the
option to your state declaration:
nginx: service.running: - parallel: True
nginx will be started in a separate process from the normal state run
and will therefore not block additional states.
Parallel States still honor requisites. If a given state requires another state that has been run in parallel then the state runtime will wait for the required state to finish.
Given this example:
sleep 10: cmd.run: - parallel: True nginx: service.running: - parallel: True - require: - cmd: sleep 10 sleep 5: cmd.run: - parallel: True
sleep 10 will be started first, then the state system will block on
starting nginx until the
sleep 10 completes. Once nginx has been ensured to
be running then the
sleep 5 will start.
This means that the order of evaluation of Salt States and requisites are
still honored, and given that in the above case,
parallel: True does not
actually speed things up.
To run the above state much faster make sure that the
sleep 5 is evaluated
sleep 10: cmd.run: - parallel: True sleep 5: cmd.run: - parallel: True nginx: service.running: - parallel: True - require: - cmd: sleep 10
Now both of the sleep calls will be started in parallel and
nginx will still
wait for the state it requires, but while it waits the
sleep 5 state will
Parallel States do not prevent you from creating parallel conflicts on your system. This means that if you start multiple package installs using Salt then the package manager will block or fail. If you attempt to manage the same file with multiple states in parallel then the result can produce an unexpected file.
Make sure that the states you choose to run in parallel do not conflict, or else, like in any parallel programming environment, the outcome may not be what you expect. Doing things like just making all states run in parallel will almost certainly result in unexpected behavior.
With that said, running states in parallel should be safe the vast majority of the time and the most likely culprit for unexpected behavior is running multiple package installs in parallel.