An introduction about how to use salt-stack and how to improve it developing new modules and states with Python

1. salt-stack
Jose Ignacio Galarza
@igalarzab

2. Index
Why it’s so cool?
How to use it?
Developing for salt-stack

3. python
+
devops

4. salt-stack

5. infrastructure
management

7. master

8. not a polling model,
PUSHING

9. instructions
send
to
the minions telling them what to do

10. PUB/SUB system on 4505
REP system on 4506

11. awesome diagram
master
SUB
minion
PUB
minion
REP
minion

12. MessagePack to
serialize the messages

13. everything is
encrypted

14. it uses first public
authentication
keys
for
master needs to know public keys of
the minions

15. then, it uses
AES for communication
* (symmetric, faster)

16. how to accept minion keys?
$ salt-key
Unaccepted Keys:
minion_1
!
$ salt-key -a minion_1

17. let’s go!
$
salt ‘*’ test.ping
!
!
!
minion_1:
True

18. minions

19. controlled machines

20. receive instructions
via
PUB/SUB ZeroMQ

21. masterless
configuration
* (salt-call)

22. modules

23. they provide the
functionality

24. S3
pip
apt
ssh
iptables
pam
nginx
apache
aliases
mysql
mount
file
upstart
quota

25. execute them with the cli!
$ salt ‘*’ cmd.run ‘ls /’
...
$ salt ‘*’ state.highstate
...

26. states

27. manage or
configure in your
hosts
what to

28. salt-stack states are just
DATA
* usually in YAML

29. they usually map to module
functions

30. understanding states
!
!
!
!
!
!
!
!
!
/etc/init/nginx.conf:
file:
- managed
- template: jinja
- user: root
- require:
- pkg: nginx

31. nginx:
pkg.installed:
- name: nginx
file:
- managed
- name: /etc/init/nginx.conf
- source: salt://nginx.conf
- require:
- pkg: nginx
service:
- running
- enable: True
- watch:
- file: /etc/nginx/nginx.conf

32. there are a lot of directives
require
watch
extend
include

33. returners

34. save the
minion output
where to

35. mongo
stdout
redis
SQL DB

36. renderers

37. language of the state
configuration

38. YAML
python
JSON
...

39. grains

40. configuration of the
machine
* read-only data
** populated at the beginning

41. using grains...
{% if grains['os'] == 'RedHat' %}
httpd:
pkg:
- installed
{% elif grains['os'] == 'Debian' %}
apache2:
pkg:
- installed
{% endif %}

42. list the grains
$ salt ‘*’ grains.ls
...
you can use them everywhere
dev:
‘os:Debian’:
- match: grain
- python_server

43. pillar

44. think of pillar as a
variable container

45. it’s data,
just as same as the states

46. create a pillar of salt...
{% if grains['os'] == 'RedHat' %}
apache: httpd
git: git
{% elif grains['os'] == 'Debian' %}
apache: apache2
git: git-core
{% endif %}

47. and use it!
apache:
pkg:
- installed
- name: {{ pillar['apache'] }}

48. only salt-stack?

49. salt-bootstrap
salt-cloud
salt-vagrant
halite

50. developing for
salt-stack

51. developing
modules

52. it’s like developing a normal
python module!
just create a file inside the _modules dir

53. every callable is
exported*
* (with some exceptions)

54. creating a module (for the pip-tools package)
import re!
!
import salt.utils!
from salt.utils.decorators import memoize!
!
REVIEW_RE = re.compile(‘([wd_-]+)==([d.]+) is available (you have ([d.]+))’)!
!
!
@memoize!
def _detect_install():!
return salt.utils.which('pip-review')!
!
!
def __virtual__():!
return 'piputils' if _detect_install() else False!

55. creating a module (for the pip-tools package)
!
def review(autoinstall=False):!
command_ret = __salt__['cmd.run'](!
'pip-review {0}'.format('-a' if autoinstall else '')!
)!
!
packages = command_ret.split('n')!
updates = {}!
!
for package in packages:!
match = REVIEW_RE.match(package)!
if match:!
name, old_v, new_v = match.groups()!
updates[name] = (old_v, new_v)!
!
return updates!

56. syncing the modules
$ salt-call saltutil.sync_modules
...
and use it!
$ salt-call piptools.review
machine:
----------
Jinja2:
- 2.7.1
- 2.6

57. useful variables like:
__salt__
__grains__
__outputter__

58. developing
states

59. it’s (also) like developing a
normal python module!
just create a file inside the _states dir

60. every callable is
exported*
* (with some exceptions)

61. the renderer structure
maps directly
to the state python module

62. creating a state (for the pip-tools package)
def keep_updated(name, min_version=None, max_version=None):!
updatable_packages = __salt__['piptools.review']()!
pkg_info = updatable_packages.get(name, None)!
!
ret = {!
'name': name,!
'result': pkg_info is not None,!
}!

63. creating a state (for the pip-tools package)
!
if package_info:!
ret['comment'] = 'Update {0} from {2} to {1}'.format(!
name, *pkg_info!
)!
ret['changes'] = {!
name: {!
'old': package_info[1],!
'new': package_info[0]!
}!
}!
else:!
ret['comment'] = 'Inexistent package {0}'.format(name)!
!
if __opts__['test']:!
ret['result'] = None!
else:!
pass # Perform the update!
!
return ret!

64. mapping the file
!
Jinja2:
pip_package:
- keep_updated
- min_version: 1.0
#
#
#
#
maps
maps
maps
maps
to
to
to
to
"name" argument
pip_package state
keep_updated funct
min_version arg

65. and that’s all!
http://twitter.com/igalarzab
http://github.com/igalarzab

66. questions?

67. thank you!