##### Primary configuration settings ##### ########################################## # Set the location of the salt master server, if the master server cannot be # resolved, then the minion will fail to start. #master: salt {% if master is defined -%} master: {{ master }}{% endif %} # Set the port used by the master reply and authentication server #master_port: 4506 {% if master_port is defined -%} master_port: {{ master_port }}{% endif %} # The user to run salt #user: root {% if salt_user is defined -%} user: {{ salt_user }}{% endif %} # The root directory prepended to these options: pki_dir, cachedir, log_file. #root_dir: / {% if root_dir is defined -%} root_dir: {{ root_dir }}{% endif %} # The directory to store the pki information in #pki_dir: /etc/salt/pki {% if pki_dir is defined -%} pki_dir: {{ pki_dir }}{% endif %} # Explicitly declare the id for this minion to use, if left commented the id # will be the hostname as returned by the python call: socket.getfqdn() # Since salt uses detached ids it is possible to run multiple minions on the # same machine but with different ids, this can be useful for salt compute # clusters. #id: {% if id is defined -%} id: {{ id }}{% endif %} # Append a domain to a hostname in the event that it does not exist. This is # useful for systems where socket.getfqdn() does not actually result in a # FQDN (for instance, Solaris). #append_domain: {% if append_domain is defined -%} append_domain: {{ append_domain }}{% endif %} # If the connection to the server is interrupted, the minion will # attempt to reconnect. sub_timeout allows you to control the rate # of reconnection attempts (in seconds). To disable reconnects, set # this value to 0. #sub_timeout: 60 {% if sub_timeout is defined -%} sub_timeout: {{ sub_timeout }}{% endif %} # Where cache data goes #cachedir: /var/cache/salt {% if cachedir is defined -%} cachedir: {{ cachedir }}{% endif %} # The minion can locally cache the return data from jobs sent to it, this # can be a good way to keep track of jobs the minion has executed # (on the minion side). By default this feature is disabled, to enable # set cache_jobs to True #cache_jobs: False {% if cache_jobs is defined -%} cache_jobs: {{ cache_jobs }}{% endif %} # When waiting for a master to accept the minion's public key, salt will # continuously attempt to reconnect until successful. This is the time, in # seconds, between those reconnection attempts. #acceptance_wait_time = 10 {% if acceptance_wait_time is defined -%} acceptance_wait_time: {{ acceptance_wait_time }}{% endif %} # When healing a dns_check is run, this is to make sure that the originally # resolved dns has not changed, if this is something that does not happen in # your environment then set this value to False. #dns_check: True {% if dns_check is defined -%} dns_check: {{ dns_check }}{% endif %} ##### Minion module management ##### ########################################## # Disable specific modules. This allows the admin to limit the level of # access the master has to the minion #disable_modules: [cmd,test] {% if disable_modules is defined -%} disable_modules: {{ disable_modules }}{% endif %} #disable_returners: [] {% if disable_returners is defined -%} disable_returners: {{ disable_returners }}{% endif %} # # Modules can be loaded from arbitrary paths. This enables the easy deployment # of third party modules. Modules for returners and minions can be loaded. # Specify a list of extra directories to search for minion modules and # returners. These paths must be fully qualified! #module_dirs: [] {% if module_dirs is defined -%} module_dirs: {{ module_dirs }}{% endif %} #returner_dirs: [] {% if returner_dirs is defined -%} returner_dirs: {{ returner_dirs }}{% endif %} #states_dirs: [] {% if states_dirs is defined -%} states_dirs: {{ states_dirs }}{% endif %} #render_dirs: [] {% if render_dirs is defined -%} render_dirs: {{ render_dirs }}{% endif %} # # A module provider can be statically overwritten or extended for the minion # via the providers option, in this case the default module will be # overwritten by the specified module. In this example the pkg module will # be provided by the yumpkg5 module instead of the system default. # # providers: # pkg: yumpkg5 # {% if providers is defined -%} providers: {{ providers }}{% endif %} # Enable Cython modules searching and loading. (Default: False) #cython_enable: False {% if cython_enable is defined -%} cython_enable: {{ cython_enable }}{% endif %} ##### State Management Settings ##### ########################################### # The state management system executes all of the state templates on the minion # to enable more granular control of system state management. The type of # template and serialization used for state management needs to be configured # on the minion, the default renderer is yaml_jinja. This is a yaml file # rendered from a jinja template, the available options are: # yaml_jinja # yaml_mako # json_jinja # json_mako # #renderer: yaml_jinja {% if renderer is defined -%} renderer: {{ renderer }}{% endif %} # # autoload_dynamic_modules Turns on automatic loading of modules found in the # environments on the master. This is turned on by default, to turn of # autoloading modules when states run set this value to False #autoload_dynamic_modules: True {% if autoload_dynamic_modules is defined -%} autoload_dynamic_modules: {{ autoload_dynamic_modules }}{% endif %} # # clean_dynamic_modules keeps the dynamic modules on the minion in sync with # the dynamic modules on the master, this means that if a dynamic module is # not on the master it will be deleted from the minion. By default this is # enabled and can be disabled by changing this value to False #clean_dynamic_modules: True {% if clean_dynamic_modules is defined -%} clean_dynamic_modules: {{ clean_dynamic_modules }}{% endif %} # # Normally the minion is not isolated to any single environment on the master # when running states, but the environment can be isolated on the minion side # by statically setting it. Remember that the recommended way to manage # environments is to isolate via the top file. #environment: None {% if environment is defined -%} environment: {{ environment }}{% endif %} # # If using the local file directory, then the state top file name needs to be # defined, by default this is top.sls. #state_top: top.sls {% if state_top is defined -%} state_top: {{ state_top }}{% endif %} ##### File Directory Settings ##### ########################################## # The Salt Minion can redirect all file server operations to a local directory, # this allows for the same state tree that is on the master to be used if # copied completely onto the minion. This is a literal copy of the settings on # the master but used to reference a local directory on the minion. # Set the file client, the client defaults to looking on the master server for # files, but can be directed to look at the local file directory setting # defined below by setting it to local. #file_client: remote {% if file_client is defined -%} file_client: {{ file_client }}{% endif %} # The file directory works on environments passed to the minion, each environment # can have multiple root directories, the subdirectories in the multiple file # roots cannot match, otherwise the downloaded files will not be able to be # reliably ensured. A base environment is required to house the top file. # Example: # file_roots: # base: # - /srv/salt/ # dev: # - /srv/salt/dev/services # - /srv/salt/dev/states # prod: # - /srv/salt/prod/services # - /srv/salt/prod/states # # Default: #file_roots: # base: # - /srv/salt {% if file_roots is defined -%} file_roots: {{ file_roots }}{% endif %} # The hash_type is the hash to use when discovering the hash of a file in # the minion directory, the default is md5, but sha1, sha224, sha256, sha384 # and sha512 are also supported. #hash_type: md5 {% if hash_type is defined -%} hash_type: {{ hash_type }}{% endif %} # The Salt pillar is searched for locally if file_client is set to local. If # this is the case, and pillar data is defined, then the pillar_roots need to # also be configured on the minion: #pillar_roots: # base: # - /srv/pillar {% if pillar_roots is defined -%} pillar_roots: {{ pillar_roots }}{% endif %} ###### Security settings ##### ########################################### # Enable "open mode", this mode still maintains encryption, but turns off # authentication, this is only intended for highly secure environments or for # the situation where your keys end up in a bad state. If you run in open mode # you do so at your own risk! #open_mode: False {% if open_mode is defined -%} open_mode: {{ open_mode }}{% endif %} ###### Thread settings ##### ########################################### # Disable multiprocessing support, by default when a minion receives a # publication a new process is spawned and the command is executed therein. #multiprocessing: True {% if multiprocessing is defined -%} multiprocessing: {{ multiprocessing }}{% endif %} ###### Logging settings ##### ########################################### # The location of the minion log file #log_file: /var/log/salt/minion # # The level of messages to send to the log file. # One of 'info', 'quiet', 'critical', 'error', 'debug', 'warning'. # Default: 'warning' #log_level: warning {% if log_level is defined -%} log_level: {{ log_level }}{% endif %} # # Logger levels can be used to tweak specific loggers logging levels. # For example, if you want to have the salt library at the 'warning' level, # but you still wish to have 'salt.modules' at the 'debug' level: # log_granular_levels: { # 'salt': 'warning', # 'salt.modules': 'debug' # } # #log_granular_levels: {} {% if log_granular_levels is defined -%} log_granular_levels: {{ log_granular_levels }}{% endif %} ###### Module configuration ##### ########################################### # Salt allows for modules to be passed arbitrary configuration data, any data # passed here in valid yaml format will be passed on to the salt minion modules # for use. It is STRONGLY recommended that a naming convention be used in which # the module name is followed by a . and then the value. Also, all top level # data must be applied via the yaml dict construct, some examples: # # A simple value for the test module: #test.foo: foo # # A list for the test module: #test.bar: [baz,quo] # # A dict for the test module: #test.baz: {spam: sausage, cheese: bread} {%- if module_settings is defined %} {%- for modules in module_settings %} {%- for module, options in modules.items() %} {%- for option in options %} {%- for key in option %} {{ module }}.{{ key }}: {{ option[key] }} {%- endfor %} {%- endfor %} {%- endfor %} {%- endfor %} {%- endif %}