Chapter 1, Starting with the Basics, starts with a discussion of the two core principles that this book focuses on: how Salt uses Python and how the Loader system works. These form the foundation of extending Salt.

Chapter 2, Writing Execution Modules, explains that the heavy lifting in most of Salt is performed by execution modules, which are often wrapped by other modules. A solid understanding of execution modules will also be key to understanding how other module types work.

Chapter 3, Extending Salt Configuration, explains that the ability to dynamically manage configuration can make some modules far more useful. Some modules won't even work without dynamic configuration. Here, we explore different ways to provide that.

Chapter 4, Wrapping States Around Modules, supports the fact that execution modules make things work, but state modules make that work persist. In this chapter, you will see how to manage execution modules using state modules.

Chapter 5, Rendering Data, shows that the renderer system allows you to add your own templating systems, increasing the power of states. Jinja and YAML are all well and good, but sometimes, you need something more.

Chapter 6, Handling Return Data, answers the query what happens to the data when a job finishes. There are many places it can go, and you can write modules to send it there.

Chapter 7, Scripting with Runners, shows that SaltStack knows that system administrators have used scripting languages for years, and they have provided a scripting environment that combines Python with the raw power of Salt.

Chapter 8, Adding External File Servers, advises not to just serve files from Salt Master. You can serve files from wherever you want with your own external file server module.

Chapter 9, Connecting to the Cloud, helps you find out how you can update existing cloud modules or add your own. Everyone uses the cloud now, and Salt Cloud connects it to Salt.

Chapter 10, Monitoring with Beacons, helps us to solve the problem that Salt isn't normally associated with monitoring, which is a shame. Beacons are one way to integrate Salt into your monitoring framework.

Chapter 11, Extending the Master, explains that Salt provides a way for you to serve the administrative needs of the Master programmatically. Bonus points for tying in your own authentication system to Salt.

Appendix A, Connecting Different Modules, gives solutions to how to fit the different components even if it is known that Salt modules are designed to play together. This appendix lays out how the different parts connect together.

Appendix B, Contributing Code Upstream, gives you tips to know where the project is screwed up or what features are missing. It doesn't have to be that way with Salt but going back to the community.

This book assumes a reasonable amount of knowledge of both Salt and the Python programming language. While you may be able to slam out some code without much experience (indeed, that is how the author got started with both), you will find it much easier with these tools already under your belt.

While the examples in this book are tested and functional, they may not be applicable to your needs. They are designed to be simple and easily understood by one who is comfortable with both Python and Salt, while still showcasing a reasonably amount of functionality.

Salt currently has a baseline of Python 2.6, which means that many older Linux distributions are still supported. As of the first edition of this book, Salt does not currently run on the Python 3.x branch. Minion-side examples are expected to work in Windows as well, except when the dependencies that they rely on aren't available.

Because both the Master and the Minion can be run on the same machine, you only need one computer to perform the examples in this book. Many of the examples do refer to software that may not be preinstalled with your operating system. In those cases, the software should still be available for download.

This book is for both new and existing Salt developers who are looking to build and write new Salt modules. Some prior Python development experience is expected.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "If there is no __virtual__() function, then the module will always be available on every system."

A block of code is set as follows:

'''
This module should be saved as salt/modules/mysqltest.py
'''
__virtualname__ = 'mysqltest'


def __virtual__():
    '''
    For now, just return the __virtualname__
    '''
    return __virtualname__


def ping():
    '''
    Returns True

    CLI Example:
        salt '*' mysqltest.ping
    '''
    return True

Any command-line input or output is written as follows:

#salt-call mymodule.test

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "When you visit your fork on GitHub again, you will see a link that says New Pull Request."

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.