How to use the command 'salt' (with examples)

Salt is a powerful open-source tool used primarily for configuration management and remote execution. One of its core features is the ability to remotely execute commands and manage the states of multiple systems, known as minions, from a central master server. Salt is designed for high scalability and rapid deployment, making it an essential tool for IT administrators who need to manage numerous servers efficiently.

Use case 1: List connected minions

Code:

salt '*' test.ping

Motivation:

Listing connected minions is a basic but important task in any Salt setup. This operation checks which minions are accessible from the master, ensuring that all systems are correctly aligned and operational. By frequently checking connectivity, administrators can swiftly identify and troubleshoot any issues with specific minions or the network itself, ensuring the reliability and responsiveness of their infrastructure.

Explanation:

• salt: This is the command used to interact with the Salt minions from the master.
• '*': This wildcard character specifies that the command should be applied to all minions connected to the master.
• test.ping: This is a Salt function that checks if the minions are online and responding. It’s analogous to a network ping, but operates at the application layer to validate connectivity within the Salt ecosystem.

Example output:

minion1:
    True
minion2:
    True
minion3:
    False

In this output, “minion1” and “minion2” are connected and responsive, while “minion3” is either offline or not responding to the ping.

Use case 2: Execute a highstate on all connected minions

Code:

salt '*' state.highstate

Motivation:

Executing a highstate is crucial for ensuring that all systems in the infrastructure adhere to the desired configuration states defined in Salt. A highstate applies the state files (SLS files) that describe the desired state of each minion. This approach helps maintain consistency across environments, automatically correcting any deviations from the required configurations.

Explanation:

• salt '*': As before, this specifies that the command should run on all connected minions.
• state.highstate: This command instructs each minion to apply all states assigned to it based on its configuration files. It’s a comprehensive operation that ensures each minion adheres to the expected configuration.

Example output:

minion1:
  ----------
  test_state:
    ----------
    __run_num__:
        0
    changes:
        ----------
    comment:
        State was already in the correct state
    duration:
        20.123 ms
    name:
        test_service
    result:
        True
minion2:
  ...

In the output, “minion1” successfully applied its highstate, with the service “test_service” already in the desired state.

Use case 3: Upgrade packages using the OS package manager (apt, yum, brew) on a subset of minions

Code:

salt '*.example.com' pkg.upgrade

Motivation:

Keeping software packages up-to-date is a routine but vital task for system administrators to ensure security, performance, and compatibility. This command targets a subset of minions, allowing administrators to perform controlled upgrades across their infrastructure. By selecting a subset, admins can evaluate the upgrades’ impact before a full deployment, minimizing potential disruptions.

Explanation:

• salt '*.example.com': This pattern targets a specific subset of minions, identified by their hostnames ending with “example.com”.
• pkg.upgrade: This Salt function triggers the package manager on each targeted minion to upgrade all upgradable packages to their latest versions.

Example output:

minion.example.com:
  ----------
  upgrade:
    ----------
    pkg1:
      ----------
      new:
        2.0
      old:
        1.9
    pkg2:
      ----------
      new:
        4.5
      old:
        4.4
minion2.example.com:
  ...

Here, “minion.example.com” had “pkg1” upgraded from version 1.9 to 2.0, and “pkg2” from 4.4 to 4.5. Such detailed output helps in verifying successful upgrades.

Use case 4: Execute an arbitrary command on a particular minion

Code:

salt 'minion_id' cmd.run "ls"

Motivation:

Executing arbitrary commands on specific minions provides the flexibility to perform ad-hoc tasks without disrupting the entire infrastructure. Whether for troubleshooting, gathering data, or managing files, this capability allows administrators to react to immediate needs efficiently and effectively. This focused approach avoids unnecessary load or distraction on other minions.

Explanation:

• salt 'minion_id': This specifies the exact minion on which the command should be executed, allowing precise control.
• cmd.run "ls": This command runs the listed shell command (here, “ls”, which lists files and directories) on the selected minion. While this example uses a simple command, any shell command can potentially be executed, demonstrating Salt’s versatility.

Example output:

minion_id:
    bin
    boot
    dev
    etc
    home

This output shows the directories in the root file system of “minion_id”, confirming the command executed successfully.

Conclusion:

The Salt command provides system administrators with robust capabilities for managing and automating tasks across numerous servers or minions. From checking connectivity to synchronizing configurations and performing targeted package upgrades, Salt’s flexibility and scalability make it an invaluable tool in today’s dynamic IT environments. As demonstrated through these examples, Salt empowers administrators to maintain order, consistency, and efficiency in large-scale infrastructures.