SRJahirTech

Linux Tutorial — Part 9: Package Management

By Suraj Ahir December 17, 2025 6 min read

Software installation on Linux is handled by package managers — tools that automate downloading, installing, updating, and removing software while handling dependencies. Understanding package management is fundamental for any Linux user, especially in server administration and DevOps.

APT — Debian/Ubuntu Package Manager

sudo apt update                      # Refresh package list
sudo apt upgrade                     # Upgrade all packages
sudo apt dist-upgrade                # Full system upgrade
sudo apt install nginx               # Install package
sudo apt install python3 git curl    # Install multiple
sudo apt remove nginx                # Remove package
sudo apt purge nginx                 # Remove with config files
sudo apt autoremove                  # Remove unused dependencies
apt search "web server"              # Search packages
apt show nginx                       # Package information
dpkg -l | grep nginx                 # Check if installed

YUM/DNF — Red Hat/CentOS Package Manager

sudo dnf update                      # Update all packages
sudo dnf install httpd               # Install Apache
sudo dnf remove httpd                # Remove package
sudo dnf search "database"           # Search
sudo dnf info mysql-server           # Package details
sudo dnf groupinstall "Development Tools"  # Install package group
rpm -qa | grep python                # List installed RPM packages

Managing PPAs and Third-Party Repos

# Add third-party repository (Ubuntu)
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.12

# Add Docker repository
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu jammy stable" | sudo tee /etc/apt/sources.list.d/docker.list
sudo apt update && sudo apt install docker-ce

Compiling from Source

# Install build tools
sudo apt install build-essential gcc make

# Generic build process
./configure --prefix=/usr/local
make
sudo make install

pip — Python Package Manager

pip3 install flask                    # Install Python package
pip3 install flask==2.3.2             # Specific version
pip3 install -r requirements.txt      # Install from file
pip3 list                             # Installed packages
pip3 show flask                       # Package details
pip3 uninstall flask                  # Remove package

Checking Installed Packages

dpkg -l                               # All installed packages
dpkg -l | grep -i python              # Search installed
apt list --installed                  # Installed with apt
which nginx                           # Find executable location
whereis nginx                         # All related files
dpkg -L nginx                         # All files installed by package

Managing Security Updates

Keeping systems updated is a critical security practice. On production servers, you typically want to apply security updates automatically but test regular updates before applying:

sudo apt install unattended-upgrades    # Install automatic updater
sudo dpkg-reconfigure unattended-upgrades  # Configure it
# Check what updates are available without installing
apt list --upgradable 2>/dev/null
sudo apt upgrade --dry-run            # Preview what would change

In production environments, package management is more controlled — you test updates in staging before applying to production, you maintain package lists in configuration management tools like Ansible, and you scan for vulnerabilities in installed packages. In Part 10, we will look at environment variables and system configuration.

Understanding Package Dependencies

Package managers do more than install software — they resolve and manage dependencies. When you install a package, the package manager calculates the full dependency tree: which other packages are required, whether compatible versions are already installed, and what needs to be upgraded or added. Understanding this process helps when installations fail due to dependency conflicts. On Debian/Ubuntu, apt-cache depends package-name shows what a package depends on. apt-cache rdepends package-name shows what other packages depend on it. When removing packages, apt autoremove cleans up packages that were installed as dependencies but are no longer needed by anything — running this regularly keeps your system clean.

Pinning and Holding Packages

Sometimes you need to keep a specific version of a package and prevent automatic upgrades — for example, when a new version of a critical service has a known issue. On Debian/Ubuntu, use sudo apt-mark hold package-name to prevent a package from being upgraded. Use apt-mark showhold to see which packages are on hold, and apt-mark unhold package-name to release the hold. On RHEL/CentOS with dnf, use dnf versionlock add package-name to achieve the same effect. Understanding version locking is important for production systems where stability matters more than always having the latest version.

Practice Exercise

Practice the full package management workflow: search for the htop package (apt search htop), show its details (apt show htop), install it (sudo apt install htop), verify installation (which htop and dpkg -l htop), check what files it installed (dpkg -L htop), run it, then remove it with sudo apt remove htop. Also run sudo apt update && apt list --upgradable to see available updates, and use apt upgrade --dry-run to simulate an upgrade without applying it.

Linux in Your Daily Engineering Practice

Linux command-line proficiency is not something you learn once and then stop improving. It is a skill that deepens continuously as you encounter new tools, new use cases, and new problems to solve. The engineers who are most effective at the command line did not become that way by reading comprehensive guides — they became that way by spending years solving real problems at the terminal, gradually accumulating a toolkit of commands, aliases, scripts, and muscle memory. The best approach is to use Linux for real work as much as possible, to look up better ways to do things you already do, and to make note of efficient patterns you observe in others' work. Over time, the terminal becomes faster than any GUI for the tasks you do repeatedly.

Putting It All Together

Every topic in technology and finance rewards the learner who goes beyond surface understanding to build genuine fluency. Fluency comes from repeated exposure, application in varied contexts, and reflection on what worked and what did not. The concepts discussed here are starting points — each one opens into a deeper field of study that could occupy years of focused learning. The most effective approach is not to try to master everything at once, but to pick the areas most relevant to your current goals, go deep there, and then expand. Depth in a few areas is more valuable than shallow familiarity with many. Build on what you know, stay curious about what you do not, and keep the practice of learning as a consistent daily habit rather than an occasional burst of effort.

The questions that make learning stick: How does this connect to what I already know? Where would I actually use this? What would happen if I tried to explain this to someone who knows nothing about it? What are the edge cases and exceptions? What is still unclear? Asking these questions transforms passive reading into active learning, and active learning is what builds the kind of understanding that is still accessible years later when you need it under real conditions.