Installing Software from Source Tarballs

1. Preparation: Setting Up Your Build Environment

Before you can build software, you need the right tools and the source code itself. Think of this as setting up your workshop.

Installing the Build Toolchain

As we discussed, your system needs a compiler (gcc), the make utility, and other essential tools to build software. These are often bundled together in a meta-package. If you haven't done so already, please open a terminal in your virtual machine and install the necessary tools for your distribution.

Obtaining the Source Code

Source code is typically distributed in a compressed archive file, often called a tarball (with an extension like .tar.gz or .tar.bz2). For this lesson, we will use the LabEx tutorial resource, which provides a sample tarball for an FTP server called pure-ftpd. This will be our practical example.

2. A Step-by-Step Guide to Installation from Source

We will now work through a complete installation. The following reading provides a self-contained lab exercise that walks you through every command. My goal is to add context to each step and connect it back to what we've learned.

Let's break down the process you're following in that tutorial.

Step A: Extract the Source Code with tar

As directed in the "Extract the Source Code..." section of the tutorial, your first action is to unpack the tarball. The command tar -zxvf pure-ftpd-1.0.53.tar.gz uses these common options:

• z: Decompress the file (it's a .gz file).
• x: Extract the files from the archive.
• v: Verbose, show the files as they are being extracted.
• f: Use the following argument as the file to operate on.

After running this, you'll have a new directory containing all the source files. You must then cd into this directory to proceed.

Step B: Configure the Build with ./configure

This is the "pre-flight check" we discussed. As shown in the "Configure and Compile..." part of the tutorial, you run the script located in the current directory (./configure).

This script generates the Makefile, which is the custom-tailored recipe for the make command. If any required libraries (dependencies) were missing, the script would fail at this stage with an error message telling you what you need to install.

Step C: Compile the Code with make

With the Makefile ready, you can now compile the code. The make command reads the Makefile and executes all the necessary commands to turn the human-readable .c files into machine-executable code.

This step does the real work. You'll see a lot of output scroll by as each source file is compiled. If it finishes without a fatal error, the software has been successfully built.

Step D: Install the Software with sudo make install

The final step is to copy the compiled files from your local source directory to the system-wide directories (like /usr/local/bin). As the tutorial explains, this requires administrative privileges, which is why you must use sudo.

After running sudo make install, the software is installed. The tutorial shows you how to verify this using the which command, which confirms the program is now in your system's PATH.

3. Managing and Uninstalling Source-Built Software

You've successfully installed the software, but a crucial part of system administration is management. How do you remove what you've just installed?

The "make uninstall" Target

The make install command copied files all over your system. A well-designed source package provides a way to reverse this.

Running sudo make uninstall executes another target in the Makefile that knows exactly which files were installed and where they are located, and removes them. This is the cleanest way to uninstall software built from source.

Important Note: Not all developers include an uninstall target in their Makefile. This is a major drawback of this installation method. If it's missing, you would have to manually hunt down and delete every file, which is difficult and error-prone.

A Better Way: checkinstall

To overcome the pitfalls of make install, many administrators use a tool called checkinstall. Instead of running sudo make install, you run sudo checkinstall. This clever utility:

1. Runs the make install process in a temporary location.
2. Tracks all the files that are created.
3. Bundles them into a standard package file for your distribution (e.g., a .deb file for Debian/Ubuntu or an .rpm file for Fedora/CentOS).
4. Installs that package using your system's package manager (dpkg or rpm).

The result is that your self-compiled software is now known to the package management system, and you can manage it just like any other package—for example, by uninstalling it with sudo apt remove <package_name>.

Conclusion

Congratulations! You have now performed a complete software installation from a source tarball. You've moved from theoretical knowledge to practical skill, a critical step in your journey to becoming a proficient Linux administrator.

Key Takeaways:

• The standard practical workflow is: tar -zxvf <file.tar.gz>, cd <directory>, ./configure, make, and finally sudo make install.
• Always ensure you have the build-essential (or "Development Tools") package installed first.
• Good source packages provide a make uninstall target for clean removal, but you must keep the source directory to use it.
• Using checkinstall is a best practice that integrates your compiled software with the system's package manager, making it much easier to manage and uninstall.

Preview of the Next Lesson:

In our next lesson, we will move from managing user-space applications to managing the very core of the operating system: the Linux kernel. You will learn how to perform a kernel update using your system's package manager and how to manage kernel modules. This will highlight the importance of using package managers for such critical system components.