The Salt system is a Python-based open-source remote execution framework for

* **Layerable** - provides layers of data abstraction (such as states call execution modules).

Executing remote management and configuration on a minion is perfect when you

want to ensure that the minion is configured and running the way you want.

Sometimes, however, you want to configure a set of minions all at once.

For example, if you want to set up a load balancer in front of a cluster of

web servers, you can ensure the load balancer is set up first. You can then

apply the same matching configuration consistently across the whole cluster,

which is known as orchestration.

* A Salt master is a server running the ``salt-master`` service that provides

management to many systems.

* A Salt minion is any system/device managed by Salt. A Salt minion can

run the ``salt-minion`` service or can be agentless using ``salt-ssh``

or ``salt-proxy``.

* A Salt Proxy process can behave as a salt-minion, which in turn connects

to an underlying device to execute commands or states. Salt Proxy

connections are typically achieved via SSH or RESTful API calls.

* Systems managed via SSH with the ``salt-ssh`` model are also considered

agentless minions under the managed systems model.

* A newer system in development is ``salt-bin``, which will.

.. image:: ../_static/img/salt-architecture.png

:align: right

:alt: Salt architecture

A server running the ``salt-master`` service is a Salt master. The Salt master

A system under control of the Salt master is considered a Salt minion.

However, minions do not require a master to be managed but can run in a stand-alone

* The ``salt-minion`` service runs as a management agent on a system.

* The ``salt-minion`` service can run pretty much anywhere you can have a

Python interpreter.

Proxy minions are a feature that enables controlling devices that,

is used to establish a connection to an underlying device, using methods native

to that device (SSH, Rest, etc).

The Salt SSH system was added to Salt as an alternative means to communicate

with minions. The Salt SSH system can be used in tandem with or as an alternative

to the standard Salt system. The Salt SSH system does not require that a Salt

minion be present on the target system. Only SSH needs to be running and port

22 open. We introduce this capability of Salt so you can appreciate the full

capability of Salt but will not be using it in this class.

.. image:: ../_static/img/saltstack-config-architecture.png

:alt: SaltStack Config architecture

Salt master/masters. These ports work in concert to receive and deliver data to the *Message

Bus*. Salt’s message bus is ZeroMQ, which creates an asynchronous network topology

to provide the fastest communication possible.

The event system is used for inter-process communication between the Salt master

and Salt minions:

* **ZeroMQ (0MQ)** - the current default socket-level library providing a flexible transport layer.

communication bus is more efficient than running a higher-level web service (http).

The remote execution system is the component that all components are built

upon, allowing for decentralized remote execution to spread load across resources.

* All keys/properties are case-sensitive. Comments begin with a hash “#”.

#. **Scalars** -``key: value`` mappings where the value can be a number, string, or boolean value.

#. **Lists** - a ``key:`` followed by a list of values where each value is on a separate line and proceeded with two spaces and a hyphen.

* Tabs are NOT allowed, use spaces ONLY.

* YAML is organized into block structures.

entry with a hyphen and a space ( “- ”).