mirror of
https://github.com/valitydev/salt.git
synced 2024-11-07 17:09:03 +00:00
212 lines
7.3 KiB
ReStructuredText
212 lines
7.3 KiB
ReStructuredText
.. _contents:
|
|
|
|
.. |vid| image:: /_static/film_link.png
|
|
:class: math
|
|
|
|
Get started with Salt
|
|
=====================
|
|
|
|
.. sidebar:: Presentations
|
|
|
|
A list of `presentations and interviews on Salt`_ (including the FLOSS
|
|
Weekly interview).
|
|
|
|
.. _`presentations and interviews on Salt`: http://saltstack.org/presentations/
|
|
|
|
Salt is a **remote execution** and **configuration management** tool.
|
|
|
|
Salt is designed to be secure using **AES encryption** and **public-key
|
|
authentication**; incredibly scalable using an advanced **ZeroMQ** topology;
|
|
fast and efficient using **msgpack**; and extensible using small and simple
|
|
**Python** modules.
|
|
|
|
Read the :doc:`Salt overview <topics/index>` for a more thorough description.
|
|
|
|
Tutorial 1: Remote execution
|
|
----------------------------
|
|
|
|
.. sidebar:: |vid| Screencasts
|
|
|
|
Watch the `remote execution screencast`__.
|
|
|
|
.. __: http://blip.tv/saltstack/salt-installation-configuration-and-remote-execution-5713423
|
|
|
|
The quickest way to see Salt in action is to run a command on a :term:`minion`
|
|
host from the :term:`master` host. This is widely known as :term:`remote
|
|
execution` — executing commands on remote hosts.
|
|
|
|
1. :doc:`Installation </topics/installation/index>`
|
|
2. :doc:`Configure the minion <topics/configuration>`
|
|
3. :doc:`Run remote commands <topics/tutorials/modules>`
|
|
|
|
Tutorial 2: Configuration management
|
|
------------------------------------
|
|
|
|
Now that you have the basics out of the way, learn to use Salt to configure
|
|
your servers. This is widely known as :term:`configuration management` —
|
|
installing packages, configuring users and services, and much more.
|
|
|
|
1. :doc:`Basic config management <topics/tutorials/states_pt1>`
|
|
2. :doc:`Less basic config management <topics/tutorials/states_pt2>`
|
|
3. :doc:`Advanced techniques <topics/tutorials/states_pt3>`
|
|
|
|
Salt in depth
|
|
=============
|
|
|
|
Setting up and using Salt is a simple task but it's capabilities run much, much
|
|
deeper. Gaining a better understanding of how Salt works will allow you to
|
|
truly make it work for you.
|
|
|
|
.. sidebar:: More tutorials!
|
|
|
|
* :doc:`Bootstraping Salt on EC2 <topics/tutorials/bootstrap_ec2>`
|
|
* :doc:`Installing Salt on FreeBSD <topics/installation/freebsd>`
|
|
|
|
.. contents:: The components of Salt
|
|
:local:
|
|
:depth: 2
|
|
|
|
:doc:`Targeting </topics/targeting/index>`
|
|
------------------------------------------
|
|
|
|
Targeting is specifying which minions should execute commands or manage server
|
|
configuration.
|
|
|
|
:doc:`Globbing and regex </topics/targeting/globbing>`
|
|
Match minions using globbing and regular expresssions.
|
|
|
|
:doc:`Grains </topics/targeting/grains>`
|
|
Match minions using bits of static information about the minion such as
|
|
OS, software versions, virtualization, CPU, memory, and much more.
|
|
|
|
:doc:`Node groups </topics/targeting/nodegroups>`
|
|
Statically define groups of minions.
|
|
|
|
:doc:`Compound matchers </topics/targeting/compound>`
|
|
Combine the above matchers as a single target.
|
|
|
|
Remote execution
|
|
----------------
|
|
|
|
Remote execution is the core functionality of Salt. Running pre-defined or
|
|
arbitrary commands on remote hosts.
|
|
|
|
**Modules**
|
|
Salt modules are the core of remote execution. They provide
|
|
functionality such as installing a package, restarting a service,
|
|
running a remote command, transferring a file — and the list goes on.
|
|
|
|
:doc:`Full list of modules </ref/modules/all/index>`
|
|
The giant list of core modules that ship with Salt
|
|
(And there are even more in the `salt-contrib`_ repository!)
|
|
|
|
:doc:`Writing modules <ref/modules/index>`
|
|
A guide on how to write Salt modules
|
|
|
|
**Returners**
|
|
Salt returners allow saving minion responses in various datastores or
|
|
to various locations in addition to display at the CLI.
|
|
|
|
:doc:`Full list of returners </ref/returners/all/index>`
|
|
Store minion responses in Redis, Mongo, Cassandra or more.
|
|
|
|
:doc:`Writing returners <ref/returners/index>`
|
|
If we're missing your favorite storage backend, webservice, or you
|
|
need a custom endpoint returners are *tiny* and simple to write.
|
|
|
|
Configuration management
|
|
------------------------
|
|
|
|
Building on the remote execution core is a robust and flexible config
|
|
management framework. Execution happens on the minions allowing
|
|
effortless, simultaneous configuration of thousands of hosts.
|
|
|
|
**States**
|
|
Express the state of a host using small, easy to read, easy to
|
|
understand configuration files. No programming required (unless you
|
|
want to).
|
|
|
|
:doc:`Full list of states <ref/states/all/index>`
|
|
Install packages, create users, transfer files, start services, and
|
|
more and more.
|
|
|
|
:doc:`Using states <ref/states/index>`
|
|
You've seen the big list of available states, now learn how to call
|
|
them.
|
|
|
|
:doc:`Highstate data structure <ref/states/highstate>`
|
|
A dry, vocabulary and technical representation of the configuration
|
|
format that states represent.
|
|
|
|
**Renderers**
|
|
Write state configuration files in the language, templating engine, or
|
|
file type of your choice. The world doesn't need yet another DSL.
|
|
|
|
:doc:`Full list of renderers <ref/renderers/all/index>`
|
|
YAML? JSON? Jinja? Mako? Python? We got you covered. (And if we
|
|
don't, new renderers are *tiny* and easy to write.)
|
|
|
|
:doc:`Renderers <ref/renderers/index>`
|
|
Salt states are only concerned with the ultimate highstate data
|
|
structure. How you create that data structure isn't our business.
|
|
Tweak a config option and use whatever you're most comfortable
|
|
with.
|
|
|
|
Miscellaneous topics
|
|
--------------------
|
|
|
|
Salt is a many splendid thing.
|
|
|
|
:doc:`File Server <ref/file_server/index>`
|
|
Salt can easily and quickly transfer files (in fact, that's how Salt
|
|
States work). Even under load, files are chunked and served.
|
|
|
|
:doc:`Syndic <ref/syndic>`
|
|
A seamless master of masters. Scale Salt to thousands of hosts or
|
|
across many different networks.
|
|
|
|
:doc:`Peer communication <ref/peer>`
|
|
Allow minions to communicate amongst themselves. For example, configure
|
|
one minion by querying live data from all the others. With great power
|
|
comes great responsibility.
|
|
|
|
:doc:`Network topology <ref/topology>`
|
|
At it's core, Salt is a highly scalable communication layer built on
|
|
top of ZeroMQ that enables remote execution and configuration
|
|
management. The possibilities are endless and Salt's future looks
|
|
bright.
|
|
|
|
:doc:`Python API interface <ref/python-api>`
|
|
Use Salt programmatically from your own scripts and programs easily and
|
|
simply via ``import salt``.
|
|
|
|
Reference
|
|
---------
|
|
|
|
:doc:`Command-line interface <ref/cli/index>`
|
|
Read the Salt manpages.
|
|
|
|
:doc:`Full list of master settings <ref/configuration/master>`
|
|
Read through the heavily-commented master configuration file.
|
|
|
|
:doc:`Full list of minion settings <ref/configuration/minion>`
|
|
Read through the heavily-commented minion configuration file.
|
|
|
|
:doc:`Full table of contents </contents>`
|
|
Dense but complete.
|
|
|
|
More information about the project
|
|
----------------------------------
|
|
|
|
:doc:`Roadmap </topics/roadmap/index>`
|
|
Where we're headed.
|
|
|
|
:doc:`Release notes </topics/releases/index>`
|
|
Where we've been.
|
|
|
|
:doc:`Community </topics/community>`
|
|
How you can get involved.
|
|
|
|
.. _`salt-contrib`: https://github.com/saltstack/salt-contrib
|
|
.. _`salt-states`: https://github.com/saltstack/salt-states
|