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
SaltStack Topics
The following are the things covered under SaltStack.
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
Have Question?