Building a CLI Tool in Python

1. From a Simple Script to a Versatile Tool

In the last lesson, we adapted our GitHub user script to take a username from the command line. This is a form of "wrapping" a task—we took the core logic (making an API call) and wrapped it in a argparse interface.

Let's look at another clear example of this process. The following video demonstrates taking an existing Python script for a Rock, Paper, Scissors game and integrating argparse to add a simple feature: personalizing the game with the player's name.

This approach is great for scripts that do one primary thing. However, most powerful DevOps tools need to handle multiple, distinct actions. For instance:

• git has commit, push, pull, branch...
• docker has run, build, ps, images...
• aws has s3, ec2, lambda...

To build a tool like this, we need to use a more advanced feature of argparse: subcommands.

2. Building Multi-Action Tools with Subcommands

Subcommands allow you to create a hierarchy of commands. You have your main script, which then calls different sub-programs based on the first argument.

argparse handles this through a sub-parser system. The setup looks like this:

1. Create the main parser: parser = argparse.ArgumentParser()
2. Add a subparser object: subparsers = parser.add_subparsers(dest='command')
   • This special object will manage all your subcommands. dest='command' is useful because it stores which subcommand was used in args.command.
3. Create a parser for each subcommand: cpu_parser = subparsers.add_parser('cpu')
   • Each subcommand gets its own ArgumentParser object.
4. Add arguments to the subcommand parser: cpu_parser.add_argument('--threshold', ...)
   • Arguments added here only apply when that specific subcommand is used.
5. Link the subcommand to a function: A common and clean pattern is to use set_defaults(func=my_function). This associates the subcommand with the function that should be executed.

This might seem complex in text, but it's a very powerful and organized pattern.

3. Project: Build a System Monitoring CLI

Remember in Module 9, you wrote Bash scripts to monitor system resources. Let's now create a more robust Python-based CLI tool to do the same.

Our goal is to create a tool named monitor.py that can be used as follows:

• python monitor.py cpu: Shows current CPU usage.
• python monitor.py memory: Shows current memory usage.
• python monitor.py disk: Shows current disk usage.

This is a perfect use case for subcommands!

Step 1: Install psutil

To get system information like CPU and memory usage in Python, the psutil library is the standard choice. It's a cross-platform library that makes these tasks simple.

Open your terminal and install it:

pip install psutil

Step 2: Write the Core Logic Functions

First, let's write the functions that do the actual work. Create a new file called monitor.py and add the following code. This separates our logic from our command-line interface.

import psutil
import argparse

def check_cpu_usage():
    """Checks and prints the current CPU usage."""
    usage = psutil.cpu_percent(interval=1)
    print(f"CPU Usage: {usage}%")

def check_memory_usage():
    """Checks and prints the current memory usage."""
    memory = psutil.virtual_memory()
    # Convert bytes to GB for readability
    total_gb = memory.total / (1024**3)
    available_gb = memory.available / (1024**3)
    print(f"Memory Usage: {memory.percent}%")
    print(f"Total: {total_gb:.2f} GB | Available: {available_gb:.2f} GB")

def check_disk_usage():
    """Checks and prints the disk usage for the root partition."""
    disk = psutil.disk_usage('/')
    # Convert bytes to GB for readability
    total_gb = disk.total / (1024**3)
    used_gb = disk.used / (1024**3)
    print(f"Disk Usage: {disk.percent}%")
    print(f"Total: {total_gb:.2f} GB | Used: {used_gb:.2f} GB")

Step 3: Build the argparse Wrapper with Subcommands

Now, let's add the CLI structure. We will create a main() function to contain this logic. Add this code to the bottom of your monitor.py file:

def main():
    # 1. Create the main parser
    parser = argparse.ArgumentParser(description="A simple system monitoring CLI.")

    # 2. Create the subparser object
    subparsers = parser.add_subparsers(dest='command', required=True, help='Available commands')

    # 3. Create the parser for the "cpu" command
    cpu_parser = subparsers.add_parser('cpu', help='Check CPU usage.')
    cpu_parser.set_defaults(func=check_cpu_usage) # Link to the function

    # 4. Create the parser for the "memory" command
    mem_parser = subparsers.add_parser('memory', help='Check memory usage.')
    mem_parser.set_defaults(func=check_memory_usage) # Link to the function

    # 5. Create the parser for the "disk" command
    disk_parser = subparsers.add_parser('disk', help='Check disk usage.')
    disk_parser.set_defaults(func=check_disk_usage) # Link to the function

    # Parse the arguments
    args = parser.parse_args()

    # Call the function associated with the chosen subcommand
    args.func()

if __name__ == "__main__":
    main()

Step 4: Run Your New Tool!

Save the file and run it from your terminal. Try all the commands:

# Check the main help message
$ python monitor.py -h
usage: monitor.py [-h] {cpu,memory,disk} ...

A simple system monitoring CLI.

positional arguments:
  {cpu,memory,disk}  Available commands
    cpu              Check CPU usage.
    memory           Check memory usage.
    disk             Check disk usage.

options:
  -h, --help         show this help message and exit

# Run each subcommand
$ python monitor.py cpu
CPU Usage: 12.8%

$ python monitor.py memory
Memory Usage: 45.1%
Total: 15.89 GB | Available: 8.72 GB

$ python monitor.py disk
Disk Usage: 60.3%
Total: 233.22 GB | Used: 140.65 GB

You have successfully built a multi-action CLI tool that wraps an automation task!

4. Seeing the Pattern in a Real-World DevOps Tool

The subcommand pattern you just implemented is not just a toy example; it's the foundation for complex, real-world DevOps tools. To see this in action, let's look at a project that builds a custom CLI for managing AWS resources.

Seeing this pattern applied to a large, practical project should solidify your understanding and show you the real power of what you've just learned.

Conclusion

Congratulations on completing the Python for DevOps module! You've gone from Python basics to building a functional, professional CLI tool. This is a huge step in your journey to DevOps mastery.

Key Takeaways:

• CLI tools can be structured to handle multiple actions using subcommands in argparse.
• The add_subparsers() method is the key to creating subcommand handlers.
• A clean design pattern is to separate core logic (the functions that do the work) from the CLI wrapper (the argparse code).
• Using set_defaults(func=...) is an elegant way to link a subcommand to the function it should execute.
• The if __name__ == "__main__": block is the standard way to make a Python file both importable as a module and runnable as a script.

Next Up: Containerization with Docker!

You've built scripts and tools. Now, how do you run them reliably on any machine, be it your laptop, a colleague's computer, or a cloud server? The answer is containerization.

In our next module, we'll dive into Docker. You'll learn how to package your applications—like the CLI tool you just built—into lightweight, portable containers. This is a cornerstone of modern DevOps, and the skills you've gained in Linux, networking, and scripting will all come together here.