SaltStack for the Absolute Beginners - Practical DevOps

Explore Salt framework to understand configuration management, infrastructure as code, and idempotent salt states. Learn how Salt master and minions, zeromq, modules, grains, pillar, top files, and salt-call enable configuration.

Learn the prerequisites for setting up a salt master and minion deployment, including host name persistence, hardware and platform requirements, port 4505/4506, time synchronization, and multi-platform minion management.

Create a free tier AWS account and launch two EC2 instances using an Ubuntu AMI and T2 micro, named salt-master and salt minion, with a key pair for access.

Set up the Salt Master by updating repositories, installing the Salt Master package, configuring its interface and port for minion connections, and starting and enabling the service.

Set up a salt master on Ubuntu by configuring the hostname, updating hosts, and following the official installation guide. Install, verify the master, bind to IP, and start the service.

Identify prerequisites for salt minions, including network connectivity to the salt master, a persistent /etc/hosts entry, and master IP setup with ports 4505 and 4506.

Install salt minion on Ubuntu, set the master in the minion config, and start the service to enable master minion communication with proper host entries.

Learn how salt key management authenticates master and minion keys, issues public/private pairs, and stores approved keys on the master, with a hands-on demo of common salt-key commands.

Learn how to manage salt keys between a master and minion by viewing pending keys, verifying fingerprints, and accepting keys to test connectivity with salt ping.

Enable auto signing to automate machine key acceptance, allowing minions to securely join the salt master. Set auto_accept to true in the master file and restart the service.

This demo shows enabling auto signing on the salt master to admit a CentOS minion, then installing and configuring the minion, updating hosts, and verifying master-minion communication.

Explore the SaltStack architecture from the salt CLI to the master, including the request server, m workers, and event publisher, enabling secure command execution and job delivery to minions.

Explore salt modules as versatile building blocks that automate tasks, manage configurations, and gather system information across minions, including execution, state, grains, pillar, and runners.

Explore SaltStack's module documentation to understand execution modules and the file module, including the touch function and its parameters, guided by official docs at docs.saltproject.io.

Explore how virtual modules act as pointers to underlying execution modules, enabling a uniform pkg install across heterogeneous operating systems by dynamically selecting zypper, yum, wind pkg, or Solaris pkg.

This demo explores virtual modules in Salt's execution modules. The pkg module remains universal for package installation and selects the execution module, such as Red Hat Zypper, Suse, and Windows.

Execute quick one-off tasks on multiple minions with Salt ad hoc requests, using execution modules and flexible targeting to run commands like hostname and package installs.

Target minions in SaltStack by validating with salt key -L, pinging all targets, and using grains and compound targets to reach CentOS or ubuntu minions.

Learn to run ad hoc commands in SaltStack with cmd.run, user.add, file.touch, and more, performing uptime checks, os info, pkg.install, and service status for minions.

Discover how salt state code replaces ad hoc commands with declarative, yaml-based state definitions to manage minions using state modules; learn to create solid state files (.sls) for scalable infrastructure.

Explore salt state modules for state files and their parameters. See the pg state module for managing software packages and the installed function with name and version.

Create dot sls salt state files, then check, dry run, test with the salt cli, lint if desired, and finally run states across minions.

Create a user with SaltStack using a solid state file, perform syntax checks and dry runs, then apply the state to all minions to verify creation and details.

Demonstrates crafting a SaltStack Apache setup on Ubuntu minions, creating a dedicated apache_setup.sls, installing Apache, managing the default index.html, and ensuring the Apache two service runs and boots.

Explore yaml basics as a data serialization language used in docker, kubernetes, and other devops tools. Compare yaml with json and xml, learn indentation, dictionaries, lists, and how validators help.

Organize configurations with the salt state tree using a top file to map minions to state files and apply the high state across your infrastructure.

Run practical SaltStack demos to build a top.sls with a single state file, install and configure Apache, validate service status, and verify access via a browser.

Demonstrates a SaltStack deployment strategy by organizing Apache states in /srv/salt/apache, creating init.sls, updating top.sls, and applying the state to an Ubuntu minion; verify the web page.

Create install, configure, and start Apache state files inside an Apache dir, include them in init.sls, and map the dir with top.sls to an Ubuntu minion for high state application.

Explore the SaltStack file server as a centralized repository for configuration files and scripts distributed to minions. Learn how watch and require requisites link states and file_routes config.

Demonstrates configuring the salt file server, placing a motd file on the server, and using a file.manage init.sls state to distribute a customized motd to minions.

Explore the Salt requisite system with watch and require statements to manage dependencies and execution order, and trigger Apache restarts on configuration changes.

Demonstrate implementing salt watch and require statements to deploy Apache, configure ports with ports.conf, and restart services automatically on changes for robust, ordered execution.

Discover how SaltStack grains represent system information, leverage static and dynamic grains, create custom grains, and target configurations by grain values for precise, scalable deployments.

Demonstrates using the grains execution module in SaltStack to run grains.ls and grains.items, extracting OS and other grain values as variables for Jinja templates and targeted minion tasks.

Learn to create custom grains in SaltStack by defining a grains map in the minion file, refreshing grains on the master, and verifying with grains.item, with an alternative placement option.

Learn to use grains as inbuilt variables in salt state files by creating a dedicated directory, using curly braces for variables, and applying a state to fetch OS and memory.

Discover how Jinja templates power dynamic SaltStack configurations by injecting variables and control statements into salt states, enabling platform-agnostic, loop-driven setups.

Learn to use Jinja templates in salt state files to define host and os variables from grains, apply conditions and loops, and create users.

Learn how pillars securely store minion-specific data, such as passwords and API keys, encrypted and accessible only to the required minions. It also covers pillar locations and refreshing pillar data.

Explore creating pillar data and pillar top files in SaltStack, verify with pillar.items, then reference data in init.sls to create a user and a file.

Masterless salt enables running salt modules locally without a master for ad hoc execution, testing, and applying states on a local host using salt call commands.

Demonstrates ad hoc and state management with masterless salt using the CLI for local task execution, including creating an SLS file and applying states in dry run and real modes.

Master agentless salt with ssh over port 22 to manage remote systems without a minion, using a yaml roaster file to store connection details and run uptime or apply states.