Lab 14: Python Scripting for System Administration

Have completed the reading on BASH and Python scripting. If you haven’t done this you will almost certainly have difficulty completing the lab!

Have completed the BASH scripting lab, this lab will take you through several similar tasks at a much faster rate

Open an SSH remote terminal session to your Linux server’s IP address

Login with your standard user’s username and password

Just like with BASH scripts we want to specify the interpreter at the beginning of our script with a sha-bang. We will be learning how to write Python3 as it’s the most recent major version.

Create a new text file named hello.py with the following text:

#!/usr/bin/env python3
print("Hello World from Python!")

Set the hello.py file to be executable by all users on the system

Try running your hello.py script now. If your system outputs Hello World from Python! you have successfully written your first Python script!

ben@2480-Z:~$ ./hello.py
Hello World from Python!
ben@2480-Z:~$

It is still possible to run system commands from inside of a Python script as well (that’s what ultimately makes them useful for shell scripting purposes after all). To do this we will need to import a special library of functions that Python can use to interact with the underlying system.

Now try using what you have learned to create and test another script named simple-backup.py which executes the command tar -czf /tmp/jsmith-backup.tar.gz /home/jsmith/ when the script is run (substitue your own username for jsmith).

Argument parsing in Python is not quite as simple as it is in BASH but with practice it actually allows for much more complex scripts to be developed. Arguments can accessed as entries in an array through the sys library. First, we need to import the sys library and then arguments will be accessed through the variables sys.argv[0] (for the script name) sys.argv[1] (for the first argument) and so on. These variables with square brackets after them are together called an array which is just a single variable that stores multiple values in different "slots" which are identified by numbers starting with zero in this case.

Try adjusting your hello.py script to look like this:

#!/usr/bin/env python3
import sys
print("The script you are running is: " + sys.argv[0])
print("Hello " + sys.argv[1] + " from Python!")

Wait, what if someone doesn’t know they are supposed to include their name as an argument though? Try running ./hello.py and see what happens.

ben@2480-Z:~$ ./hello.py
The script you are running is: ./hello.py
Traceback (most recent call last):
  File "/home/ben/./hello.py", line 4, in <module>
    print("Hello " + sys.argv[1] + " from Python!")
                     ~~~~~~~~^^^
IndexError: list index out of range
ben@2480-Z:~$

Unlike BASH Python is a little more particular about things and if you try to access a variable that doesn’t exist it will give you an error. This isn’t very user friendly so let’s add a conditional to check and see if an argument was supplied or not.

It’s also possible to capture the standard output of a command and put that into a variable for use just as we did with BASH. We can use the output of the date +%Y%m%d command in a variable to make our backup script a little bit nicer (though again, there are better ways to get a date in Python itself once you get more familiar with the language). You’ll also see that in order to capture the output we need to use the subprocess library instead of the os library we were using before.

It is important to note that while this script works, it’s just a simple example and not well written because it is easily broken by giving a username which doesn’t actually exist on the system, or trying to backup files you don’t have permission to access, etc. A better script could be written to check for all of these things as well as other errors. If the script is to be used by more people than the original author (and in the best cases, even then) it is important for usability and security purposes to do these sorts of checks, particularly if the script accepts user input such as an argument.

Create a file-generator.py script on your system like the one below and see if you can figure out how it works before testing it:

#!/usr/bin/env python3
import subprocess
BASENAME = "sample-file"
print("Welcome to the sample file generation utility!")
print("Files will be created using the filename format " + BASENAME + "X.extension")
NUM = int(input("Enter the number of files you wish to create, then press Enter: "))
EXTENSION = input("Enter the extension (without the leading period) to put on the files: ")
for CURNUM in range(0, NUM):
    subprocess.call(["touch", BASENAME + str(CURNUM) + "." + EXTENSION])
print("Created " + str(NUM) + " file(s).")

There are a couple of differences to note when comparing this with the similar BASH script we created.

Try running the script and see if you were correct about what it does and how it works.

See if you can modify the script so you can specify a starting and an ending number for the files rather than just a number of files to be created.

See if you can add a check to the script which will display an example of a filename that will be created and asking the user if that looks correct before actually creating all the files. If the user enters N then do not create the files. Hint, you will need to do a little further research on using python if statements to check user input.

Just as in BASH we can create functions in python as well. Try entering this simple sample as hello-func.py:

#!/usr/bin/env python3
def helloname():
    name = input("Enter your name, followed by enter: ")
    print("Hello " + name + "!")


print("This program will welcome you twice to be extra nice!")
helloname()
print("At this point we could be doing lots of other stuff in our script or be in a loop, etc.")
helloname()
print("Thanks for playing!")

This should work pretty much the same way that the BASH equivalent script did. See if you can figure out what will happen when you run it, then try it out and see if you were correct. Note that functions need to be declared (listed) before you use them in your script so it would be common to see them at the beginning of the file as in this example.

One difference with functions in Python is how you pass information in and out of functions. Instead of using arguments you include the information in the function call itself and you can return information from the function which can be used immediately or can be stored into a variable. Try modifying hello-func.py like this:

#!/usr/bin/env python3
def askname():
    yourname = input("Enter your name, followed by enter: ")
    return yourname


def helloname(thename):
    print("Hello " + thename + "!")


print("There are lots of ways to make use of the two functions in this script. We can pass a pre-specified string to a function:")
helloname("world")
print("We can ask for your name and use it immediately as input into the hello function:")
helloname(askname())
print("We can take a string already stored in a variable and pass the variable to a function:")
somevariable = "Linux Lover"
helloname(somevariable)
print("Or we can ask you your name again and store your name in a variable once and then use it a few times:")
userentry = askname()
helloname(userentry)
print("Thanks for playing " + userentry + "!")

See if you can figure out what this script will do and how it works before running it, then try it out and see if you were correct.

Now that you have a grasp on the fundamentals of Python scripting for system administration see if you can write a Python script which can be used to modify the name of all files in the current directory which share the same extension such as those created by file-generator.sh. The goals for your script should be:

Don’t be afraid to try using search engines for help with this. The goal of this lab is not to make you into a professional programmer but to introduce you enough to Python shell scripting so that you can create useful scripts with resources such as search engines available to you.

Close the SSH session

If you are using the Administrative PC in Netlab instead of your own computer as the administrative computer you should also shut down that system in the usual way each time you are done with the Netlab system and then end your Netlab Reservation. You should do these steps each time you finish using the adminsitrative PC in future labs as well.