# salt ‘*‘ sys.doc | grep "salt ‘*‘"

salt ‘*‘ acl.delfacl user myuser /tmp/house/kitchen

salt ‘*‘ acl.delfacl default:group mygroup /tmp/house/kitchen

salt ‘*‘ acl.delfacl d:u myuser /tmp/house/kitchen

salt ‘*‘ acl.delfacl g myuser /tmp/house/kitchen /tmp/house/livingroom

salt ‘*‘ acl.getfacl /tmp/house/kitchen

salt ‘*‘ acl.getfacl /tmp/house/kitchen /tmp/house/livingroom

salt ‘*‘ acl.addfacl user myuser rwx /tmp/house/kitchen

salt ‘*‘ acl.addfacl default:group mygroup rx /tmp/house/kitchen

salt ‘*‘ acl.addfacl d:u myuser 7 /tmp/house/kitchen

salt ‘*‘ acl.addfacl g mygroup 0 /tmp/house/kitchen /tmp/house/livingroom

salt ‘*‘ acl.version

salt ‘*‘ acl.wipefacls /tmp/house/kitchen

salt ‘*‘ acl.wipefacls /tmp/house/kitchen /tmp/house/livingroom

salt ‘*‘ aliases.get_target <alias>

salt ‘*‘ aliases.has_target <alias> <target>

salt ‘*‘ aliases.list_aliases

salt ‘*‘ aliases.rm_alias <alias>

salt ‘*‘ aliases.set_target <alias> <target>

salt ‘*‘ alternatives.check_installed name path

salt ‘*‘ alternatives.display <command name>

salt ‘*‘ alternatives.install name link path priority

salt ‘*‘ alternatives.remove name path

salt ‘*‘ alternatives.show_current emacs

salt ‘*‘ archive.gunzip /tmp/sourcefile.txt.gz

salt ‘*‘ archive.gunzip template=jinja /tmp/{{grains.id}}.txt.gz

salt ‘*‘ archive.gzip /tmp/sourcefile.txt

salt ‘*‘ archive.gzip template=jinja /tmp/{{grains.id}}.txt

salt ‘*‘ archive.rar /tmp/rarfile.rar /tmp/sourcefile1 /tmp/sourcefile2

salt ‘*‘ archive.rar template=jinja /tmp/rarfile.rar /tmp/sourcefile1 /tmp/{{grains.id}}.txt

salt ‘*‘ archive.tar cjvf /tmp/tarfile.tar.bz2 /tmp/file_1 /tmp/file_2

salt ‘*‘ archive.tar template=jinja cjvf /tmp/salt.tar.bz2 {{grains.saltpath}}

salt ‘*‘ archive.unrar /tmp/rarfile.rar /home/strongbad/ file_1 file_2

salt ‘*‘ archive.unrar template=jinja /tmp/rarfile.rar /tmp/{{grains.id}}/ file_1 file_2

salt ‘*‘ archive.unzip /tmp/zipfile.zip /home/strongbad/ file_1 file_2

salt ‘*‘ archive.unzip template=jinja /tmp/zipfile.zip /tmp/{{grains.id}}/ file_1 file_2

salt ‘*‘ archive.zip /tmp/zipfile.zip /tmp/sourcefile1 /tmp/sourcefile2

salt ‘*‘ archive.zip template=jinja /tmp/zipfile.zip /tmp/sourcefile1 /tmp/{{grains.id}}.txt

salt ‘*‘ cmd.exec_code ruby ‘puts "cheese"‘

salt ‘*‘ cmd.has_exec cat

salt ‘*‘ cmd.retcode "file /bin/bash"

salt ‘*‘ cmd.retcode template=jinja "file {{grains.pythonpath[0]}}/python"

salt ‘*‘ cmd.retcode "grep f" stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.run "ls -l | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run template=jinja "ls -l /tmp/{{grains.id}} | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run "Get-ChildItem C:\ " shell=‘powershell‘

salt ‘*‘ cmd.run "grep f" stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.run_all "ls -l | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_all template=jinja "ls -l /tmp/{{grains.id}} | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_all "grep f" stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.run_stderr "ls -l | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_stderr template=jinja "ls -l /tmp/{{grains.id}} | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_stderr "grep f" stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.run_stdout "ls -l | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_stdout template=jinja "ls -l /tmp/{{grains.id}} | awk ‘/foo/{print \$2}‘"

salt ‘*‘ cmd.run_stdout "grep f" stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.script salt://scripts/runme.sh

salt ‘*‘ cmd.script salt://scripts/runme.sh ‘arg1 arg2 "arg 3"‘

salt ‘*‘ cmd.script salt://scripts/windows_task.ps1 args=‘ -Input c:\tmp\infile.txt‘ shell=‘powershell‘

salt ‘*‘ cmd.script salt://scripts/runme.sh stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.script_retcode salt://scripts/runme.sh

salt ‘*‘ cmd.script_retcode salt://scripts/runme.sh stdin=‘one\ntwo\nthree\nfour\nfive\n‘

salt ‘*‘ cmd.which cat

salt ‘*‘ cmd.which_bin ‘[pip2, pip, pip-python]‘

salt ‘*‘ config.backup_mode

salt ‘*‘ config.dot_vals host

salt ‘*‘ qemu.gather_bootstrap_script True

salt ‘*‘ config.get pkg:apache

salt ‘*‘ config.manage_mode

salt ‘*‘ config.option redis.host

salt ‘*‘ config.valid_fileproto salt://path/to/file

salt ‘*‘ cp.cache_dir salt://path/to/dir

salt ‘*‘ cp.cache_file salt://path/to/file

salt ‘*‘ cp.cache_files salt://pathto/file1,salt://pathto/file1

salt ‘*‘ cp.cache_local_file /etc/hosts

salt ‘*‘ cp.cache_master

salt ‘*‘ cp.get_dir salt://path/to/dir/ /minion/dest

salt ‘*‘ cp.get_file salt://path/to/file /minion/dest

salt ‘*‘ cp.get_file "salt://{{grains.os}}/vimrc" /etc/vimrc template=jinja

salt ‘*‘ cp.get_file_str salt://my/file

salt ‘*‘ cp.get_template salt://path/to/template /minion/dest

salt ‘*‘ cp.get_url salt://my/file /tmp/mine

salt ‘*‘ cp.get_url http://www.slashdot.org /tmp/index.html

salt ‘*‘ cp.hash_file salt://path/to/file

salt ‘*‘ cp.is_cached salt://path/to/file

salt ‘*‘ cp.list_master

salt ‘*‘ cp.list_master_dirs

salt ‘*‘ cp.list_minion

salt ‘*‘ cp.list_states

salt ‘*‘ cp.push /etc/fstab

salt ‘*‘ cron.list_tab root

salt ‘*‘ cron.list_tab root

salt ‘*‘ cron.raw_cron root

salt ‘*‘ cron.rm_job root /usr/local/weekly

salt ‘*‘ cron.rm_job root /usr/bin/foo dayweek=1

salt ‘*‘ cron.rm_env root MAILTO

salt ‘*‘ cron.rm_job root /usr/local/weekly

salt ‘*‘ cron.rm_job root /usr/bin/foo dayweek=1

salt ‘*‘ cron.set_env root MAILTO user@example.com

salt ‘*‘ cron.set_job root ‘*‘ ‘*‘ ‘*‘ ‘*‘ 1 /usr/local/weekly

salt ‘*‘ cron.set_special @hourly ‘echo foobar‘

salt ‘*‘ cron.write_cron_file root /tmp/new_cron

salt ‘*‘ cron.write_cron_file_verbose root /tmp/new_cron

salt ‘*‘ daemontools.full_restart <service name>

salt ‘*‘ daemontools.get_all

salt ‘*‘ daemontools.reload <service name>

salt ‘*‘ daemontools.restart <service name>

salt ‘*‘ daemontools.start <service name>

salt ‘*‘ daemontools.status <service name>

salt ‘*‘ daemontools.stop <service name>

salt ‘*‘ daemontools.term <service name>

salt ‘*‘ data.cas <key> <value> <old_value>

salt ‘*‘ data.clear

salt ‘*‘ data.dump ‘{‘eggs‘: ‘spam‘}‘

salt ‘*‘ data.getval <key>

salt ‘*‘ data.getvals <key> [<key> ...]

salt ‘*‘ data.load

salt ‘*‘ data.update <key> <value>

salt ‘*‘ disk.inodeusage

salt ‘*‘ disk.usage

salt ‘*‘ django.collectstatic <settings_module>

salt ‘*‘ django.command <settings_module> <command>

salt ‘*‘ django.createsuperuser <settings_module> user user@example.com

salt ‘*‘ django.loaddata <settings_module> <comma delimited list of fixtures>

salt ‘*‘ django.syncdb <settings_module>

salt ‘*‘ dnsmasq.version

salt ‘*‘ dnsmasq.get_config

salt ‘*‘ dnsmasq.get_config file=/etc/dnsmasq.conf

salt ‘*‘ dnsmasq.set_config domain=mydomain.com

salt ‘*‘ dnsmasq.set_config follow=False domain=mydomain.com

salt ‘*‘ dnsmasq.set_config file=/etc/dnsmasq.conf domain=mydomain.com

salt ‘*‘ dnsmasq.version

salt ‘*‘ dnsutil.hosts_append /etc/hosts 127.0.0.1 ad1.yuk.co,ad2.yuk.co

salt ‘*‘ dnsutil.hosts_delete /etc/hosts ad1.yuk.co

salt ‘*‘ dnsutil.hosts_delete /etc/hosts ad2.yuk.co,ad1.yuk.co

salt ‘*‘ dnsutil.parse_hosts

salt ‘*‘ event.fire ‘stuff to be in the event‘ ‘tag‘

salt ‘*‘ event.fire_master ‘stuff to be in the event‘ ‘tag‘

salt ‘*‘ extfs.attributes /dev/sda1

salt ‘*‘ extfs.blocks /dev/sda1

salt ‘*‘ extfs.dump /dev/sda1

salt ‘*‘ extfs.mkfs /dev/sda1 fs_type=ext4 opts=‘acl,noexec‘

salt ‘*‘ extfs.tune /dev/sda1 force=True label=wildstallyns opts=‘acl,noexec‘

salt ‘*‘ file.append /etc/motd \

salt ‘*‘ file.check_file_meta /etc/httpd/conf.d/httpd.conf salt://http/httpd.conf ‘{hash_type: ‘md5‘, ‘hsum‘: <md5sum>}‘ root, root, ‘755‘ base

salt ‘*‘ file.check_hash /etc/fstab md5=<md5sum>

salt ‘*‘ file.check_managed /etc/httpd/conf.d/httpd.conf salt://http/httpd.conf ‘{hash_type: ‘md5‘, ‘hsum‘: <md5sum>}‘ root, root, ‘755‘ jinja True None None base

salt ‘*‘ file.check_perms /etc/sudoers ‘{}‘ root root 400

salt ‘*‘ file.chgrp /etc/passwd root

salt ‘*‘ file.chown /etc/passwd root root

salt ‘*‘ file.comment /etc/modules pcspkr

salt ‘*‘ file.contains /etc/crontab ‘mymaintenance.sh‘

salt ‘*‘ file.contains_glob /etc/foobar ‘*cheese*‘

salt ‘*‘ file.contains_regex /etc/crontab

salt ‘*‘ file.contains_regex_multiline /etc/crontab ‘^maint‘

salt ‘*‘ file.directory_exists /etc

salt ‘*‘ file.file_exists /etc/passwd

salt ‘*‘ file.find / type=f name=\*.bak size=+10m

salt ‘*‘ file.find /var mtime=+30d size=+10m print=path,size,mtime

salt ‘*‘ file.find /var/log name=\*.[0-9] mtime=+30d size=+10m delete

salt ‘*‘ file.get_diff /home/fred/.vimrc salt://users/fred/.vimrc

salt ‘*‘ file.get_gid /etc/passwd

salt ‘*‘ file.get_group /etc/passwd

salt ‘*‘ file.get_hash /etc/shadow

salt ‘*‘ file.get_managed /etc/httpd/conf.d/httpd.conf jinja salt://http/httpd.conf ‘{hash_type: ‘md5‘, ‘hsum‘: <md5sum>}‘ root root ‘755‘ base None None

salt ‘*‘ file.get_mode /etc/passwd

salt ‘*‘ file.get_selinux_context /etc/hosts

salt ‘*‘ file.get_sum /etc/passwd sha512

salt ‘*‘ file.get_uid /etc/passwd

salt ‘*‘ file.get_user /etc/passwd

salt ‘*‘ file.gid_to_group 0

salt ‘*‘ file.group_to_gid root

salt ‘*‘ file.makedirs /opt/code

salt ‘*‘ file.makedirs_perms /opt/code

salt ‘*‘ file.manage_file /etc/httpd/conf.d/httpd.conf ‘{}‘ salt://http/httpd.conf ‘{hash_type: ‘md5‘, ‘hsum‘: <md5sum>}‘ root root ‘755‘ base ‘‘

salt ‘*‘ file.mkdir /opt/jetty/context

salt ‘*‘ file.patch /opt/file.txt /tmp/file.txt.patch

salt ‘*‘ file.sed /etc/httpd/httpd.conf ‘LogLevel warn‘ ‘LogLevel info‘

salt ‘*‘ file.remove /tmp/foo

salt ‘*‘ file.rename /path/to/src /path/to/dst

salt ‘*‘ file.restorecon /home/user/.ssh/authorized_keys

salt ‘*‘ file.sed /etc/httpd/httpd.conf ‘LogLevel warn‘ ‘LogLevel info‘

salt ‘*‘ file.contains /etc/crontab ‘mymaintenance.sh‘

salt ‘*‘ file.set_mode /etc/passwd 0644

salt ‘*‘ file.set_selinux_context path <role> <type> <range>

salt ‘*‘ file.source_list salt://http/httpd.conf ‘{hash_type: ‘md5‘, ‘hsum‘: <md5sum>}‘ base

salt ‘*‘ file.stats /etc/passwd

salt ‘*‘ file.symlink /path/to/file /path/to/link

salt ‘*‘ file.touch /var/log/emptyfile

salt ‘*‘ file.uid_to_user 0

salt ‘*‘ file.uncomment /etc/hosts.deny ‘ALL: PARANOID‘

salt ‘*‘ file.user_to_uid root

salt ‘*‘ gem.install vagrant

salt ‘*‘ gem.sources_add http://rubygems.org/

salt ‘*‘ gem.sources_list

salt ‘*‘ gem.sources_remove http://rubygems.org/

salt ‘*‘ gem.uninstall vagrant

salt ‘*‘ gem.update vagrant

salt ‘*‘ gem.update_system

salt ‘*‘ git.add /path/to/git/repo /path/to/file

salt ‘*‘ git.archive /path/to/repo /path/to/archive.tar.gz

salt ‘*‘ git.checkout /path/to/repo somebranch user=jeff

salt ‘*‘ git.checkout /path/to/repo opts=‘testbranch -- conf/file1 file2‘

salt ‘*‘ git.checkout /path/to/repo rev=origin/mybranch opts=--track

salt ‘*‘ git.clone /path/to/repo git://github.com/saltstack/salt.git

salt ‘*‘ git.clone /path/to/repo.git\

salt ‘*‘ git.commit /path/to/git/repo ‘The commit message‘

salt ‘*‘ git.config_get /path/to/repo user.email

salt ‘*‘ git.config_set /path/to/repo user.email me@example.com

salt ‘*‘ git.describe /path/to/repo

salt ‘*‘ git.describe /path/to/repo develop

salt ‘*‘ git.fetch /path/to/repo ‘--all‘

salt ‘*‘ git.fetch cwd=/path/to/repo opts=‘--all‘ user=johnny

salt ‘*‘ git.init /path/to/repo.git opts=‘--bare‘

salt ‘*‘ git.fetch /path/to/repo

salt ‘*‘ git.merge /path/to/repo @{upstream}

salt ‘*‘ git.pull /path/to/repo opts=‘--rebase origin master‘

salt ‘*‘ git.push /path/to/git/repo remote-name

salt ‘*‘ git.rebase /path/to/repo master

salt ‘*‘ git.rebase /path/to/repo ‘origin master‘

salt ‘*‘ git.remote_get /path/to/repo

salt ‘*‘ git.remote_get /path/to/repo upstream

salt ‘*‘ git.remote_set /path/to/repo remote_url=git@github.com:saltstack/salt.git

salt ‘*‘ git.remote_set /path/to/repo origin git@github.com:saltstack/salt.git

salt ‘*‘ git.remotes /path/to/repo

salt ‘*‘ git.reset /path/to/repo master

salt ‘*‘ git.revision /path/to/repo mybranch

salt ‘*‘ git.rm /path/to/git/repo /path/to/file

salt ‘*‘ git.stash /path/to/repo master

salt ‘*‘ git.status /path/to/git/repo

salt ‘*‘ git.submodule /path/to/repo.git/sub/repo

salt ‘*‘ grains.get pkg:apache

salt ‘*‘ grains.item os

salt ‘*‘ grains.item os osrelease oscodename

salt ‘*‘ grains.item host sanitize=True

salt ‘*‘ grains.items

salt ‘*‘ grains.items sanitize=True

salt ‘*‘ grains.ls

salt ‘*‘ grains.setval key val

salt ‘*‘ group.add foo 3456

salt ‘*‘ group.chgid foo 4376

salt ‘*‘ group.delete foo

salt ‘*‘ group.getent

salt ‘*‘ group.info foo

salt ‘*‘ grub.conf

salt ‘*‘ grub.version

salt ‘*‘ hg.archive /path/to/repo output=/tmp/archive.tgz fmt=tgz

salt ‘*‘ hg.clone /path/to/repo https://bitbucket.org/birkenfeld/sphinx

salt ‘*‘ hg.describe /path/to/repo

salt ‘*‘ hg.pull /path/to/repo ‘-u‘

salt ‘*‘ hg.revision /path/to/repo mybranch

salt ‘*‘ hosts.add_host <ip> <alias>

salt ‘*‘ hosts.get_alias <ip addr>

salt ‘*‘ hosts.get_ip <hostname>

salt ‘*‘ hosts.has_pair <ip> <alias>

salt ‘*‘ hosts.list_hosts

salt ‘*‘ hosts.rm_host <ip> <alias>

salt ‘*‘ hosts.set_host <ip> <alias>

salt ‘*‘ qemu_nbd.bootstrap /srv/salt-images/host.qcow 4096 qcow2

salt ‘*‘ img.mount_image /tmp/foo

salt ‘*‘ img.seed /tmp/image.qcow2

salt ‘*‘ img.umount_image /mnt/foo

salt ‘*‘ ip.apply_network_settings

salt ‘*‘ ip.build_bond bond0 mode=balance-alb

salt ‘*‘ ip.build_interface eth0 eth <settings>

salt ‘*‘ ip.build_network_settings <settings>

salt ‘*‘ ip.build_routes eth0 <settings>

salt ‘*‘ ip.down eth0

salt ‘*‘ ip.get_bond bond0

salt ‘*‘ ip.get_interface eth0

salt ‘*‘ ip.get_network_settings

salt ‘*‘ ip.get_routes eth0

salt ‘*‘ ip.up eth0

salt ‘*‘ iptables.append filter INPUT rule=‘-m state --state RELATED,ESTABLISHED -j ACCEPT‘

salt ‘*‘ iptables.delete filter INPUT position=3

salt ‘*‘ iptables.delete filter INPUT rule=‘-m state --state RELATED,ESTABLISHED -j ACCEPT‘

salt ‘*‘ iptables.flush filter

salt ‘*‘ iptables.get_policy filter INPUT

salt ‘*‘ iptables.get_rules

salt ‘*‘ iptables.get_saved_policy filter INPUT

salt ‘*‘ iptables.get_saved_policy filter INPUT conf_file=/etc/iptables.saved

salt ‘*‘ iptables.get_saved_rules

salt ‘*‘ iptables.insert filter INPUT position=3 rule=‘-m state --state RELATED,ESTABLISHED -j ACCEPT‘

salt ‘*‘ iptables.save /etc/sysconfig/iptables

salt ‘*‘ iptables.set_policy filter INPUT ACCEPT

salt ‘*‘ iptables.version

salt ‘*‘ key.finger

salt ‘*‘ keyboard.get_sys

salt ‘*‘ keyboard.get_x

salt ‘*‘ keyboard.set_sys dvorak

salt ‘*‘ keyboard.set_x dvorak

salt ‘*‘ kmod.available

salt ‘*‘ kmod.check_available kvm

salt ‘*‘ kmod.is_loaded kvm

salt ‘*‘ kmod.load kvm

salt ‘*‘ kmod.lsmod

salt ‘*‘ kmod.mod_list

salt ‘*‘ kmod.remove kvm

salt ‘*‘ locale.get_locale

salt ‘*‘ locale.list_avail

salt ‘*‘ locale.set_locale ‘en_US.UTF-8‘

salt ‘*‘ locate.locate

salt ‘*‘ locate.stats

salt ‘*‘ locate.updatedb

salt ‘*‘ locate.version

salt ‘*‘ logrotate.set rotate 2

salt ‘*‘ logrotate.set /var/log/wtmp rotate 2

salt ‘*‘ logrotate.show_conf

salt ‘*‘ lowpkg.file_list httpd

salt ‘*‘ lowpkg.file_list httpd postfix

salt ‘*‘ lowpkg.file_list

salt ‘*‘ lowpkg.file_list httpd

salt ‘*‘ lowpkg.file_list httpd postfix

salt ‘*‘ lowpkg.file_list

salt ‘*‘ lowpkg.list_pkgs

salt ‘*‘ lowpkg.verify

salt ‘*‘ match.compound ‘L@cheese,foo and *‘

salt ‘*‘ match.data ‘spam:eggs‘

salt ‘*‘ match.glob ‘*‘

salt ‘*‘ match.grain ‘os:Ubuntu‘

salt ‘*‘ match.grain_pcre ‘os:Fedo.*‘

salt ‘*‘ match.ipcidr ‘192.168.44.0/24‘

salt ‘*‘ match.list ‘server1,server2‘

salt ‘*‘ match.pcre ‘.*‘

salt ‘*‘ match.pillar ‘cheese:foo‘

salt ‘*‘ mine.get ‘*‘ network.interfaces

salt ‘*‘ mine.get ‘os:Fedora‘ network.interfaces grain

salt ‘*‘ mine.send network.interfaces eth0

salt ‘*‘ mine.update

salt ‘*‘ monit.monitor <service name>

salt ‘*‘ monit.restart <service name>

salt ‘*‘ monit.start <service name>

salt ‘*‘ monit.stop <service name>

salt ‘*‘ monit.summary

salt ‘*‘ monit.summary <service name>

salt ‘*‘ monit.unmonitor <service name>

salt ‘*‘ mount.active

salt ‘*‘ mount.fstab

salt ‘*‘ mount.is_fuse_exec sshfs

salt ‘*‘ mount.mount /mnt/foo /dev/sdz1 True

salt ‘*‘ mount.remount /mnt/foo /dev/sdz1 True

salt ‘*‘ mount.rm_fstab /mnt/foo

salt ‘*‘ mount.set_fstab /mnt/foo /dev/sdz1 ext4

salt ‘*‘ mount.swapoff /root/swapfile

salt ‘*‘ mount.swapon /root/swapfile

salt ‘*‘ mount.swaps

salt ‘*‘ mount.umount /mnt/foo

salt ‘*‘ ‘*‘ network.arp

salt ‘*‘ network.dig archlinux.org

salt ‘*‘ network.hwaddr eth0

salt ‘*‘ network.in_subnet 10.0.0.0/16

salt ‘*‘ network.interfaces

salt ‘*‘ network.ip_addrs

salt ‘*‘ network.ip_addrs6

salt ‘*‘ network.netstat

salt ‘*‘ network.ping archlinux.org

salt ‘*‘ network.subnets

salt ‘*‘ network.traceroute archlinux.org

salt ‘*‘ nginx.configtest

salt ‘*‘ nginx.signal reload

salt ‘*‘ nginx.version

salt ‘*‘ partition.align_check /dev/sda minimal 1

salt ‘*‘ partition.check 1

salt ‘*‘ partition.cp /dev/sda 2 3

salt ‘*‘ partition.get_id /dev/sda 1

salt ‘*‘ partition.mkfs /dev/sda2 fat32

salt ‘*‘ partition.mklabel /dev/sda msdos

salt ‘*‘ partition.mkpart /dev/sda primary fat32 0 639

salt ‘*‘ partition.mkpartfs /dev/sda logical ext2 440 670

salt ‘*‘ partition.name /dev/sda 1 ‘My Documents‘

salt ‘*‘ partition.part_list /dev/sda

salt ‘*‘ partition.part_list /dev/sda unit=s

salt ‘*‘ partition.part_list /dev/sda unit=kB

salt ‘*‘ partition.probe

salt ‘*‘ partition.probe /dev/sda

salt ‘*‘ partition.rescue /dev/sda 0 8056

salt ‘*‘ partition.resize /dev/sda 3 200 850

salt ‘*‘ partition.rm /dev/sda 5

salt ‘*‘ partition.set /dev/sda 1 boot on

salt ‘*‘ partition.set_id /dev/sda 1 83

salt ‘*‘ partition.name /dev/sda 1 boot

salt ‘*‘ pecl.install fuse

salt ‘*‘ pecl.list

salt ‘*‘ pecl.uninstall fuse

salt ‘*‘ pecl.update fuse

salt ‘*‘ pillar.data

salt ‘*‘ pillar.data key=‘roles‘

salt ‘*‘ pillar.ext ‘libvirt: _‘

salt ‘*‘ pillar.get pkg:apache

salt ‘*‘ pillar.data

salt ‘*‘ pillar.data key=‘roles‘

salt ‘*‘ pillar.raw

salt ‘*‘ pillar.raw key=‘roles‘

salt ‘*‘ pip.freeze /home/code/path/to/virtualenv/

salt ‘*‘ pip.install <package name>,<package2 name>

salt ‘*‘ pip.install requirements=/path/to/requirements.txt

salt ‘*‘ pip.install <package name> bin_env=/path/to/virtualenv

salt ‘*‘ pip.install <package name> bin_env=/path/to/pip_bin

salt ‘*‘ pip.install markdown,django editable=git+https://github.com/worldcompany/djangoembed.git#egg=djangoembed upgrade=True no_deps=True

salt ‘*‘ pip.list salt

salt ‘*‘ pip.uninstall <package name>,<package2 name>

salt ‘*‘ pip.uninstall requirements=/path/to/requirements.txt

salt ‘*‘ pip.uninstall <package name> bin_env=/path/to/virtualenv

salt ‘*‘ pip.uninstall <package name> bin_env=/path/to/pip_bin

salt ‘*‘ pkg.latest_version <package name>

salt ‘*‘ pkg.latest_version <package name> fromrepo=epel-testing

salt ‘*‘ pkg.latest_version <package1> <package2> <package3> ...

salt ‘*‘ pkg.clean_metadata

salt ‘*‘ pkg.compare ‘0.2.4-0‘ ‘<‘ ‘0.2.4.1-0‘

salt ‘*‘ pkg.compare pkg1=‘0.2.4-0‘ oper=‘<‘ pkg2=‘0.2.4.1-0‘

salt ‘*‘ pkg.del_repo myrepo

salt ‘*‘ pkg.del_repo myrepo basedir=/path/to/dir

salt ‘*‘ pkg.file_list httpd

salt ‘*‘ pkg.file_list httpd postfix

salt ‘*‘ pkg.file_list

salt ‘*‘ pkg.file_list httpd

salt ‘*‘ pkg.file_list httpd postfix

salt ‘*‘ pkg.file_list

salt ‘*‘ pkg.get_repo myrepo

salt ‘*‘ pkg.get_repo myrepo basedir=/path/to/dir

salt ‘*‘ pkg.group_diff ‘Perl Support‘

salt ‘*‘ pkg.group_info ‘Perl Support‘

salt ‘*‘ pkg.group_install groups=‘["Group 1", "Group 2"]‘

salt ‘*‘ pkg.group_install ‘My Group‘ skip=‘["foo", "bar"]‘

salt ‘*‘ pkg.group_install ‘My Group‘ include=‘["foo", "bar"]‘

salt ‘*‘ pkg.group_list

salt ‘*‘ pkg.install <package name>

salt ‘*‘ pkg.install pkgs=‘["foo", "bar"]‘

salt ‘*‘ pkg.install pkgs=‘["foo", {"bar": "1.2.3-4.el6"}]‘

salt ‘*‘ pkg.install sources=‘[{"foo": "salt://foo.rpm"}, {"bar": "salt://bar.rpm"}]‘

salt ‘*‘ pkg.latest_version <package name>

salt ‘*‘ pkg.latest_version <package name> fromrepo=epel-testing

salt ‘*‘ pkg.latest_version <package1> <package2> <package3> ...

salt ‘*‘ pkg.list_pkgs

salt ‘*‘ pkg.list_repos

salt ‘*‘ pkg.list_upgrades

salt ‘*‘ pkg.mod_repo reponame enabled=1 gpgcheck=1

salt ‘*‘ pkg.mod_repo reponame basedir=/path/to/dir enabled=1

salt ‘*‘ pkg.mod_repo reponame baseurl= mirrorlist=http://host.com/

salt ‘*‘ pkg.perform_cmp ‘0.2.4-0‘ ‘0.2.4.1-0‘

salt ‘*‘ pkg.perform_cmp pkg1=‘0.2.4-0‘ pkg2=‘0.2.4.1-0‘

salt ‘*‘ pkg.purge <package name>

salt ‘*‘ pkg.purge <package1>,<package2>,<package3>

salt ‘*‘ pkg.purge pkgs=‘["foo", "bar"]‘

salt ‘*‘ pkg.refresh_db

salt ‘*‘ pkg.remove <package name>

salt ‘*‘ pkg.remove <package1>,<package2>,<package3>

salt ‘*‘ pkg.remove pkgs=‘["foo", "bar"]‘

salt ‘*‘ pkg.upgrade

salt ‘*‘ pkg.upgrade_available <package name>

salt ‘*‘ pkg.verify

salt ‘*‘ pkg.version <package name>

salt ‘*‘ pkg.version <package1> <package2> <package3> ...

salt ‘*‘ pkg_resource.add_pkg ‘{}‘ bind 9

salt ‘*‘ pkg_resource.check_desired

salt ‘*‘ pkg_resource.compare

salt ‘*‘ pkg_resource.find_changes

salt ‘*‘ pkg_resource.pack_pkgs ‘["foo", {"bar": 1.2}, "baz"]‘

salt ‘*‘ pkg_resource.pack_sources ‘[{"foo": "salt://foo.rpm"}, {"bar": "salt://bar.rpm"}]‘

salt ‘*‘ pkg_resource.parse_targets

salt ‘*‘ pkg_resource.perform_cmp

salt ‘*‘ pkg_resource.sort_pkglist ‘["3.45", "2.13"]‘

salt ‘*‘ pkg_resource.stringify ‘vim: 7.127‘

salt ‘*‘ pkg_resource.version vim

salt ‘*‘ pkg_resource.version foo bar baz

salt ‘*‘ pkg_resource.version ‘python*‘

salt ‘*‘ puppet.fact kernel

salt ‘*‘ puppet.facts

salt ‘*‘ puppet.noop

salt ‘*‘ puppet.noop tags=basefiles::edit,apache::server

salt ‘*‘ puppet.noop debug

salt ‘*‘ puppet.noop apply /a/b/manifest.pp modulepath=/a/b/modules tags=basefiles::edit,apache::server

salt ‘*‘ puppet.run

salt ‘*‘ puppet.run tags=basefiles::edit,apache::server

salt ‘*‘ puppet.run debug

salt ‘*‘ puppet.run apply /a/b/manifest.pp modulepath=/a/b/modules tags=basefiles::edit,apache::server

salt ‘*‘ quota.get_mode

salt ‘*‘ quota.off

salt ‘*‘ quota.on

salt ‘*‘ quota.report /media/data

salt ‘*‘ quota.set /media/data user=larry block-soft-limit=1048576

salt ‘*‘ quota.set /media/data group=painters file-hard-limit=1000

salt ‘*‘ quota.stats

salt ‘*‘ quota.warn

salt ‘*‘ rbenv.default

salt ‘*‘ rbenv.default 2.0.0-p0

salt ‘*‘ rbenv.install

salt ‘*‘ rbenv.install_ruby 2.0.0-p0

salt ‘*‘ rbenv.is_installed

salt ‘*‘ rbenv.list

salt ‘*‘ rbenv.uninstall_ruby 2.0.0-p0

salt ‘*‘ rbenv.update

salt ‘*‘ rbenv.versions

salt ‘*‘ ret.get_fun mysql network.interfaces

salt ‘*‘ ret.get_jid redis 20421104181954700505

salt ‘*‘ ret.get_jids mysql

salt ‘*‘ ret.get_minions mysql

salt ‘*‘ rvm.do 2.0.0 <command>

salt ‘*‘ rvm.gemset_copy foobar bazquo

salt ‘*‘ rvm.gemset_create 2.0.0 foobar

salt ‘*‘ rvm.gemset_delete 2.0.0 foobar

salt ‘*‘ rvm.gemset_empty 2.0.0 foobar

salt ‘*‘ rvm.gemset_list

salt ‘*‘ rvm.gemset_list_all

salt ‘*‘ rvm.get

salt ‘*‘ rvm.install

salt ‘*‘ rvm.install_ruby 1.9.3-p385

salt ‘*‘ rvm.is_installed

salt ‘*‘ rvm.list

salt ‘*‘ rvm.reinstall_ruby 1.9.3-p385

salt ‘*‘ rvm.rubygems 2.0.0 1.8.24

salt ‘*‘ rvm.set_default 2.0.0

salt ‘*‘ rvm.wrapper <ruby_string> <wrapper_prefix>

salt ‘*‘ saltutil.find_job <job id>

salt ‘*‘ saltutil.is_running state.highstate

salt ‘*‘ saltutil.kill_job <job id>

salt ‘*‘ saltutil.refresh_modules

salt ‘*‘ saltutil.refresh_pillar

salt ‘*‘ saltutil.regen_keys

salt ‘*‘ saltutil.revoke_key

salt ‘*‘ saltutil.running

salt ‘*‘ saltutil.signal_job <job id> 15

salt ‘*‘ saltutil.sync_all

salt ‘*‘ saltutil.sync_grains

salt ‘*‘ saltutil.sync_modules

salt ‘*‘ saltutil.sync_outputters

salt ‘*‘ saltutil.sync_renderers

salt ‘*‘ saltutil.sync_returners

salt ‘*‘ saltutil.sync_states

salt ‘*‘ saltutil.term_job <job id>

salt ‘*‘ saltutil.update 0.10.3

salt ‘*‘ service.disable <service name>

salt ‘*‘ service.disabled <service name>

salt ‘*‘ service.enable <service name>

salt ‘*‘ service.enabled <service name>

salt ‘*‘ service.get_all

salt ‘*‘ service.get_all limit=upstart

salt ‘*‘ service.get_all limit=sysvinit

salt ‘*‘ service.get_disabled

salt ‘*‘ service.get_disabled limit=upstart

salt ‘*‘ service.get_disabled limit=sysvinit

salt ‘*‘ service.get_enabled

salt ‘*‘ service.get_enabled limit=upstart

salt ‘*‘ service.get_enabled limit=sysvinit

salt ‘*‘ service.reload <service name>

salt ‘*‘ service.restart <service name>

salt ‘*‘ service.start <service name>

salt ‘*‘ service.status <service name>

salt ‘*‘ service.stop <service name>

salt ‘*‘ shadow.info root

salt ‘*‘ shadow.set_date username 0

salt ‘*‘ shadow.set_inactdays username 7

salt ‘*‘ shadow.set_maxdays username 90

salt ‘*‘ shadow.set_mindays username 7

salt ‘*‘ shadow.set_password root ‘$1$UYCIxa628.9q**QCjM4a..‘

salt ‘*‘ shadow.set_warndays username 7

salt ‘*‘ sqlite3.fetch /root/test.db ‘SELECT * FROM test;‘

salt ‘*‘ sqlite3.indexes /root/test.db

salt ‘*‘ sqlite3.indices /root/test.db

salt ‘*‘ sqlite3.modify /root/test.db ‘CREATE TABLE test(id INT, testdata TEXT);‘

salt ‘*‘ sqlite3.sqlite_version

salt ‘*‘ sqlite3.tables /root/test.db

salt ‘*‘ sqlite3.version

salt ‘*‘ ssh.auth_keys root

salt ‘*‘ ssh.check_key <user> <key> <enc> <comment> <options>

salt ‘*‘ root salt://ssh/keyfile

salt ‘*‘ ssh.check_known_host <user> <hostname> key=‘AAAA...FAaQ==‘

salt ‘*‘ ssh.get_known_host <user> <hostname>

salt ‘*‘ ssh.host_keys

salt ‘*‘ ssh.recv_known_host <hostname> enc=<enc> port=<port>

salt ‘*‘ ssh.rm_auth_key <user> <key>

salt ‘*‘ ssh.rm_known_host <user> <hostname>

salt ‘*‘ ssh.set_auth_key <user> ‘<key>‘ enc=‘dsa‘

salt ‘*‘ ssh.set_auth_key_from_file <user>                salt://ssh_keys/<user>.id_rsa.pub

salt ‘*‘ ssh.set_known_host <user> fingerprint=‘xx:xx:..:xx‘                  enc=‘ssh-rsa‘ config=‘.ssh/known_hosts‘

salt ‘*‘ state.clear_cache

salt ‘*‘ state.high ‘{"vim": {"pkg": ["installed"]}}‘

salt ‘*‘ state.highstate

salt ‘*‘ state.low ‘{"state": "pkg", "fun": "installed", "name": "vi"}‘

salt ‘*‘ state.running

salt ‘*‘ state.show_highstate

salt ‘*‘ state.show_lowstate

salt ‘*‘ state.show_sls core,edit.vim dev

salt ‘*‘ state.show_top

salt ‘*‘ state.single pkg.installed name=vim

salt ‘*‘ state.sls core,edit.vim dev

salt ‘*‘ state.template ‘<Path to template on the minion>‘

salt ‘*‘ state.template_str ‘<Template String>‘

salt ‘*‘ state.top reverse_top.sls

salt ‘*‘ status.all_status

salt ‘*‘ status.cpuinfo

salt ‘*‘ status.cpustats

salt ‘*‘ status.custom

salt ‘*‘ status.diskstats

salt ‘*‘ status.diskusage [paths and/or filesystem types]

salt ‘*‘ status.diskusage         # usage for all filesystems

salt ‘*‘ status.diskusage / /tmp  # usage for / and /tmp

salt ‘*‘ status.diskusage ext?    # usage for ext[234] filesystems

salt ‘*‘ status.diskusage / ext?  # usage for / and all ext filesystems

salt ‘*‘ status.loadavg

salt ‘*‘ status.meminfo

salt ‘*‘ status.netdev

salt ‘*‘ status.netstats

salt ‘*‘ status.pid <sig>

salt ‘*‘ status.procs

salt ‘*‘ status.uptime

salt ‘*‘ status.vmstats

salt ‘*‘ status.w

salt ‘*‘ supervisord.add <name>

salt ‘*‘ supervisord.custom "mstop ‘*gunicorn*‘"

salt ‘*‘ supervisord.remove <name>

salt ‘*‘ supervisord.reread

salt ‘*‘ supervisord.restart <service>

salt ‘*‘ supervisord.start <service>

salt ‘*‘ supervisord.status

salt ‘*‘ supervisord.status_raw

salt ‘*‘ supervisord.stop <service>

salt ‘*‘ supervisord.update

salt ‘*‘ sys.argspec pkg.install

salt ‘*‘ sys.argspec sys

salt ‘*‘ sys.argspec

salt ‘*‘ sys.doc

salt ‘*‘ sys.doc sys

salt ‘*‘ sys.doc sys.doc

salt ‘*‘ sys.doc network.traceroute user.info

salt ‘*‘ sys.list_functions

salt ‘*‘ sys.list_functions sys

salt ‘*‘ sys.list_functions sys user

salt ‘*‘ sys.list_modules

salt ‘*‘ sys.reload_modules

salt ‘*‘ sysctl.assign net.ipv4.ip_forward 1

salt ‘*‘ sysctl.get net.ipv4.ip_forward

salt ‘*‘ sysctl.persist net.ipv4.ip_forward 1

salt ‘*‘ sysctl.show

salt ‘*‘ system.halt

salt ‘*‘ system.init 3

salt ‘*‘ system.poweroff

salt ‘*‘ system.reboot

salt ‘*‘ system.shutdown

salt ‘*‘ test.arg 1 "two" 3.1 txt="hello" wow=‘{a: 1, b: "hello"}‘

salt ‘*‘ test.arg_repr 1 "two" 3.1 txt="hello" wow=‘{a: 1, b: "hello"}‘

salt ‘*‘ test.collatz 3

salt ‘*‘ test.conf_test

salt ‘*‘ test.cross_test file.gid_to_group 0

salt ‘*‘ test.echo ‘foo bar baz quo qux‘

salt ‘*‘ test.fib 3

salt ‘*‘ test.get_opts

salt ‘*‘ test.kwarg num=1 txt="two" env=‘{a: 1, b: "hello"}‘

salt ‘*‘ test.not_loaded

salt ‘*‘ test.outputter foobar

salt ‘*‘ test.ping

salt ‘*‘ test.provider service

salt ‘*‘ test.providers

salt ‘*‘ test.rand_sleep 60

salt ‘*‘ test.retcode 42

salt ‘*‘ test.sleep 20

salt ‘*‘ test.tty tty0 ‘This is a test‘

salt ‘*‘ test.tty pts3 ‘This is a test‘

salt ‘*‘ test.version

salt ‘*‘ test.versions_information

salt ‘*‘ test.versions_report

salt ‘*‘ timezone.get_hwclock

salt ‘*‘ timezone.get_offset

salt ‘*‘ timezone.get_zone

salt ‘*‘ timezone.get_zonecode

salt ‘*‘ timezone.set_hwclock UTC

salt ‘*‘ timezone.set_zone ‘America/Denver‘

salt ‘*‘ timezone.zone_compare ‘America/Denver‘

salt ‘*‘ user.add name <uid> <gid> <groups> <home> <shell>

salt ‘*‘ user.chfullname foo "Foo Bar"

salt ‘*‘ user.chgid foo 4376

salt ‘*‘ user.chgroups foo wheel,root True

salt ‘*‘ user.chhome foo /home/users/foo True

salt ‘*‘ user.chhomephone foo "7735551234"

salt ‘*‘ user.chroomnumber foo 123

salt ‘*‘ user.chshell foo /bin/zsh

salt ‘*‘ user.chuid foo 4376

salt ‘*‘ user.chworkphone foo "7735550123"

salt ‘*‘ user.delete name remove=True force=True

salt ‘*‘ user.getent

salt ‘*‘ user.info root

salt ‘*‘ user.list_groups foo

salt ‘*‘ user.list_users

salt ‘*‘ virtualenv.create /path/to/new/virtualenv

本文出自 “DavideyLee” 博客，谢绝转载！

salt之sys_doc