SaltStack
SaltStack intelligent, event-driven IT automation software
About SaltStack
SaltStack intelligent automation delivers, event-driven security, cloud and configuration management for the complexity and scale of a software-defined world.
Salt is a Python-based open-source configuration management software and remote execution engine. Supporting the 'Infrastructure as Code' approach to deployment and cloud management, it competes primarily with Puppet, Chef, and Ansible
- Control
- Optimize
- Secure
- Innovate
SaltStack Topics
The following are the things covered under SaltStack.
SETTING UP THE SALT MASTER
Turning on the Salt Master is easy -- just turn it on! The default configuration is suitable for the vast majority of installations. The Salt Master can be controlled by the local Linux/Unix service manager
Finding the Salt Master
When a minion starts, by default it searches for a system that resolves to the salt hostname on the network. If found, the minion initiates the handshake and key authentication process with the Salt master.
Setting up a Salt Minion
The Salt Minion can operate with or without a Salt Master. This walk-through assumes that the minion will be connected to the master
Sending the First Commands
Salt commands allow for a vast set of functions to be executed and for specific minions and groups of minions to be targeted for execution.
Getting to Know the Functions
Salt comes with a vast library of functions available for execution, and Salt functions are self-documenting. To see what functions are available on the minions execute the sys.doc function
Salt States
The state system is already available with a basic Salt setup, no additional configuration is required. States can be set up immediately.
Course Contents
The following are the course contents offered for SaltStack
- Introducing Salt
- Installing Salt
- Dependencies
- Optional Dependencies
- Configuring Salt
- A game of ping pong
- Masterless Salt
- Summary
- The structure of a remote execution command
- Command-line options
- Targeting strings
- Glob matching
- Perl-compatible regular expression matching
- List matching
- Grain and pillar matching
- Compound matching
- Remote execution modules and functions
- Adding users
- Installing packages
- Managing services
- Monitoring minion states
- Running arbitrary commands
- Master and minions
- Targeting minions
- Glob
- Perl Compatible Regular Expression (PCRE)
- List
- Subnet
- Grain
- Grain PCRE
- Pillar
- Compound
- Nodegroup
- Using module functions
- test.ping
- test.echo
- test.sleep
- test.version
- pkg.install
- pkg.remove
- file.replace
- Other file functions
- Various user and group functions
- sys.doc
- SLS file trees
- SLS files
- Tying things together with top files
- Organizing the SLS directories
- Using states for configuration management
- Using include blocks
- Ordering with requisites
- require
- watch
- onchanges
- onfail
- use
- prereq
- Inverting requisites
- Extending SLS files
- The basics of grains
- Using grains for minion-specific data
- Centralizing variables with pillars
- Managing files dynamically with templates
- A quick Jinja primer
- Exploring the source
- Cross-calling execution modules
- Grains and the __virtual__ function
- The__opts__ and __pillar__ functions
- Reformatting return data
- An advanced example
- Our first state
- The pieces of a state declaration
- Expanding to encompass multiple pieces of state
- Dependencies using requisites
- The require requisite
- The watch requisite
- Other requisites
- The _in requisites
- Master and Minions
- Targeting Minions
- Using module functions
- Using include blocks
- Ordering with requisites
- prereq
- Inverting requisites
- Using Grains for Minion-specific data
- Centralizing variables with Pillars
- Managing files dynamically with templates
- A quick Jinja primer
- Looking at the event system
- Reviewing the basics
- The structure of event data
- Watching event data
- Namespacing events
- Some common events
- Common cloud events
- Salt API events
- Adding a new minion
- Jinja2
- apache2 or httpd?
- Defining secure minion-specific data in pillar
- The highstate
- Environments
- Expanding our base environment
- Storing our states in VersionControl
- Setting up Salt Cloud
- Creating a cloud provider configuration
- Creating cloud VM profiles
- Creating and destroying machines
- Managing groups of VMs with map files
- Salt on Amazon Web Services
- The Salt event system
- Listening for events
- Firing events from Salt
- Reacting to events
- Using Salt's local client
- Scripting with the local client
- Using different targets
- Combining jobs to add more logic
- The final module
- Understanding file formats
- Building a templating renderer
- Troubleshooting renderers
- Returning data to external destinations
- Returning data to the master
- Listening to event data
- Your first returner
- Securing Salt configuration
- Key management
- Troubleshooting Problems
- Addressing the problem source
- Where is the trouble?
- The Master to Minion communication
- The network and CPU congestion
- Checking the Minion load
- Querying the Salt job data
- Using debug and trace modes
- info
- warn
- error
- debug/trace
- Running services in debug mode
- Using salt-call locally
- Understanding pillar_roots
- Templating pillar_roots
- Calling out to other modules
- Using Salt's external pillars
- Understanding SDB
- Securely storing passwords
- Staying simple
- Using SDB URIs
- Configuring SDB
- Performing SDB lookups
- Getting data
- Setting data
- Deleting data
- Comparing pillars and SDB
- Where the data is generated
- Differences in drivers
- Salt Cloud and others
- Remote shells
- Using rosters
- The flat roster
- host
- port
- user
- passwd
- sudo
- priv
- timeout
- thin_dir
- Other built-in rosters
- scan
- cache
- cloud
- ansible
- Building dynamic rosters
- Using Salt SSH
- Using a Saltfile
- Salt versus Salt SSH
- Architecture
- Performance
- Understanding the salt-thin agent
- Building the thin package
- Including extra modules
- Deploying the thin package
- Executing the thin package
- Looking at the event system
- Reviewing the basics
- The structure of event data
- Watching event data
- Monitoring basics
- Establishing a baseline
- Reading the system vitals in Salt
- Monitoring with Returners
- Configuring Reactors
- Writing Reactors
- Looking at Salt's HTTP library
- Why a Salt-specific library?
- Using the http.query function
- Using the http.query state
- Using http.query with Reactors
- What is Salt API?
- Setting up Salt API
- Using SaltAPI
- Orchestration
- Integration with existing shell scripts
- Testing and automation.
- Deploying SaltStack and maintenance
- SaltStack on Vagrant
- Addressing the problem source
- Where is the trouble?
- Master-to-minion communication
- Network and CPU congestion
- Checking minion load
- Querying the Salt job data
- Using debug and trace modes
- info
- warn
- error
- debug/trace
- Running services in debug mode
- Using salt-call locally
- Working with YAML
- YAML basics
- dict
- list
- YAML idiosyncrasies
- Spacing
- Numbers
- Booleans
- List items
- Troubleshooting YAML
- Loading modules
- Standard modules
- Extending the loader system
- Loading modules with Python
- Detecting grains
- Using other detection methods
- Writing Salt modules
- Hidden objects
- The __virtual__() function
- Formatting your code
- Virtual modules
- Using the salt.utils library
- Cross-calling with the __salt__ dictionary
- Getting configuration parameters
- Handling imports
- Reusing code
- Logging messages
- Using the __func_alias__ dictionary
- Validating data
- Formatting strings
- The final module
- Troubleshooting execution modules
- Using salt-call
- Troubleshooting grains and pillars
- SaltStack on Docker
- Managing Instractructure with Dockerfile
- SaltStack on Windows
- Bootstrapping Agents - Windows
- Installing with Salt Bootstrap
- Testing the Salt minion
- Salt Minion Installation
- Installation Prerequisites
- Running the Salt Minion on Windows as an Unprivileged User
- Create the Unprivileged User that the Salt Minion will Run As
- Add the New User to the Access Control List for the Salt Folder
- Update the Windows Service User for the salt-minion Service
- Create a Build Environment
- 1. Working Directory
- 2. Setup the Python Environment
- 3. Salt in Editable Mode
- 4. Setup Salt Configuration
- SINGLE COMMAND BOOTSTRAP SCRIPT
- Windows Salt Installer
- Setting up a MongoDB Cluster with SalstStack
- Setting up a Hadoop Cluster with SalstStack
- Troubleshooting file servers
- Start small
- Test on a Minion
- Event System
- Event Bus
- Event types
- Listening for Events
- Firing Events
- Watching for data
- Keeping an eye on things
- Validating configuration
- The beacon() function
- Watching for beacons
- The final beacon module
- Troubleshooting beacons
- Looking at the event system
- Reviewing the basics
- The structure of event data
- Watching event data
- Installing the event listener
- Using the event listener
- Firing custom data
- Namespacing events
- Namespacing guidelines
- Some common events
- Configuring reactors
- Writing reactors
- Calling execution modules
- Calling runner modules
- Calling wheel modules
- Writing more complex reactors
- Sending out alerts
- Using webhooks
- Reactors calling reactors
- A word on engines
- Looking at Thorium basics
- Enabling Thorium
- Setting up the Thorium directory tree
- Writing Thorium SLS files
- Using requisites
- Using the register
- Looking forward
- Learning how queues work
- Adding to the queue
- Listing queues
- Listing items in a queue
- Processing queue items
- Deleting items from a queue
- Using queues with the reactor
- Spreading out State runs
- Dividing tasks among minions
- Looking at Salt's HTTP library
- Why a Salt-specific library?
- Using the http.query function
- GET versus POST
- Decoding return data
- Using the http.query state
- Using http.query with reactors
- What is the Salt API?
- Setting up the Salt API
- CherryPy
- Tornado
- WSGI
- Creating SSL certificates
- Configuring authentication
- The external authentication module
- Taking your first steps with the Salt API
- Issuing one-off commands
Download
Download SaltStack course plan