How To Install Specific Version of Package on Ubuntu Linux

Ubuntu’s package management system is both powerful and flexible, allowing users to install, update, and remove software with ease. While installing the latest version of a package is straightforward, there are many situations where you might need to install a specific version instead. Whether you’re maintaining compatibility with other software, avoiding known bugs in newer releases, or ensuring a stable development environment, knowing how to manage package versions is an essential skill for Ubuntu users.

This comprehensive guide will walk you through multiple methods for installing specific package versions on Ubuntu Linux, complete with detailed examples, troubleshooting advice, and best practices to keep your system secure and stable.

Understanding Package Versioning in Ubuntu

Before diving into installation methods, it’s important to understand how Ubuntu packages are versioned and managed. This foundational knowledge will help you navigate the package ecosystem more effectively.

Package Naming Conventions

Ubuntu packages follow a consistent naming structure that includes the package name and version information. A typical package version might look like 1.2.3-4ubuntu5, where:

• 1.2.3 represents the upstream version (from the original developers)
• -4 indicates the Debian revision
• ubuntu5 shows Ubuntu-specific modifications

This versioning scheme helps you identify exactly which iteration of the software you’re working with. Major version changes usually indicate significant feature updates, while minor version increments typically represent bug fixes or small improvements.

Version Control in APT Repository

The Advanced Package Tool (APT) system manages packages across different Ubuntu repositories. These repositories include:

• Main: Officially supported, free and open-source software
• Universe: Community-maintained, free and open-source software
• Restricted: Proprietary drivers and software
• Multiverse: Software with legal or copyright restrictions

Each Ubuntu release maintains its own set of repositories, with package versions frozen at certain points. This versioning stability is a cornerstone of Ubuntu’s reliability but can sometimes limit access to specific versions you might need.

Package Dependencies

One complexity of package management in Ubuntu is the interdependence between packages. Installing a specific version of one package might require particular versions of other packages. This dependency chain can sometimes make version-specific installations challenging, especially for core system components.

When packages evolve, their dependencies often change too. An older package might require libraries no longer available in newer Ubuntu releases, or a newer package might depend on updated libraries incompatible with other software on your system.

Why Install Specific Package Versions?

There are several compelling reasons why you might need to install a particular version of a package rather than simply using the latest available version.

Compatibility Requirements

Development environments often require precise package versions to ensure consistent behavior across different systems. For instance, a web application might depend on PHP 7.4 rather than PHP 8.0 due to functionality changes between versions.

Similarly, some software explicitly requires certain dependency versions to function correctly. Enterprise applications, in particular, often certify their software only for specific versions of libraries or runtime environments. Deviating from these specifications might lead to unexpected behavior or complete failure.

Stability Concerns

While newer isn’t always better. New package versions can introduce bugs, performance regressions, or interface changes that disrupt your workflow. Many system administrators follow the principle of “if it isn’t broken, don’t fix it,” preferring to stick with known, stable versions rather than risking disruption from updates.

In production environments, stability is paramount. Installing a specific version that has proven reliable can be preferred over updating to the latest release without thorough testing. Rolling back to a previous version after a problematic update is another common scenario requiring version-specific installation skills.

Security Considerations

While keeping packages updated is generally recommended for security, there are exceptions. Occasionally, security patches might be backported to older versions, making them more secure than newer releases in certain contexts. Additionally, newly released versions might not yet have undergone sufficient security hardening.

Understanding the security implications of different package versions requires staying informed about vulnerability announcements and patch releases. The Ubuntu Security Notices page is an invaluable resource for tracking security-relevant updates across package versions.

Pre-Installation Steps

Before attempting to install a specific package version, there are preliminary steps you should take to ensure success.

Updating Repository Information

First, ensure your package lists are up-to-date by running:

sudo apt update

This command refreshes your system’s knowledge of available packages and their versions without actually installing anything. Without current repository data, you might not see all available versions or encounter errors during installation.

The update process connects to all repositories configured in your /etc/apt/sources.list file and any files in the /etc/apt/sources.list.d/ directory. If you haven’t updated recently, this step is especially important as repository contents change frequently.

Checking Available Versions

Once your repository information is current, you can check which versions of a package are available. There are two primary commands for this purpose:

Using apt-cache policy:

apt-cache policy package_name

For example:

apt-cache policy nginx

This will display the installed version (if any), the candidate for installation, and all available versions with their repository sources.

Alternatively, you can use:

apt list --all-versions package_name

For example:

apt list --all-versions python3

This command provides a more concise list of available versions. The output includes the package name, available versions, and the architecture (like amd64).

Understanding the output is crucial. Each version will be associated with a specific repository, which helps you determine where a particular version comes from and whether you need to add additional repositories to access the version you need.

Method 1: Installing Specific Versions with APT

The APT package manager provides straightforward ways to install specific package versions. This method is generally the preferred approach when the desired version is available in your configured repositories.

Basic Syntax and Command Structure

The basic syntax for installing a specific version is:

sudo apt install package_name=version_number

For example, to install version 1.18.0-0ubuntu1 of nginx:

sudo apt install nginx=1.18.0-0ubuntu1

The equals sign tells APT to look for that exact version rather than installing the latest available version. If you specify a version that doesn’t exist or isn’t accessible from your configured repositories, you’ll receive an error message.

Remember that package names are case-sensitive, and version numbers must be typed exactly as they appear in the apt-cache output. Even a minor typographical error will cause the installation to fail.

Step-by-Step Installation Process

Let’s walk through a complete example of installing a specific version of PHP:

1. First, update your repository information:

   sudo apt update

2. Check available PHP versions:

   apt-cache policy php

3. The output might look something like:

   php:
     Installed: (none)
     Candidate: 2:7.4+76ubuntu1
     Version table:
        2:8.1+92ubuntu1 500
            500 http://archive.ubuntu.com/ubuntu jammy/main amd64 Packages
        2:8.0+76ubuntu2 500
            500 http://archive.ubuntu.com/ubuntu focal/main amd64 Packages
        2:7.4+76ubuntu1 500
            500 http://archive.ubuntu.com/ubuntu bionic/main amd64 Packages

4. Install the specific version you need:

   sudo apt install php=2:7.4+76ubuntu1

5. Verify the installation:

   php --version

This process works similarly for other popular packages like Apache, Node.js, or Python. For example, to install Node.js version 14.x:

sudo apt install nodejs=14.17.6-1nodesource1

Preventing Automatic Updates

After installing a specific version, you’ll likely want to prevent it from being automatically updated during system updates. There are two main approaches:

Using apt-mark hold:

sudo apt-mark hold package_name

For example:

sudo apt-mark hold nginx

This command marks the package as “held,” preventing automatic upgrades. To see all held packages:

apt-mark showhold

To release a package for updating later:

sudo apt-mark unhold package_name

Alternatively, you can create an APT preferences file to pin a package to a specific version:

sudo nano /etc/apt/preferences.d/pin-nginx

Add content like:

Package: nginx
Pin: version 1.18.0-0ubuntu1
Pin-Priority: 1001

The higher priority (1001) ensures this version is preferred over others, effectively preventing automatic upgrades to newer versions.

Method 2: Using the dpkg Command

When a specific package version isn’t available in your current repositories, you can install it directly using the dpkg command with a downloaded .deb file.

Finding and Downloading .deb Files

The official Ubuntu package archive at packages.ubuntu.com is the primary source for .deb files. Navigate to the website, search for your package, and locate the specific version you need. Each package page lists versions available across different Ubuntu releases.

For example, to find a specific version of the curl package:

1. Visit packages.ubuntu.com
2. Search for “curl”
3. Select the appropriate architecture (usually amd64 for most systems)
4. Choose the Ubuntu release that contains your desired version
5. Download the .deb file by clicking on the architecture link

Alternatively, you can use the Launchpad website or package archives from older Ubuntu releases. For historical versions, http://old-releases.ubuntu.com can be a valuable resource.

Always verify the authenticity of downloaded .deb files. Check file checksums when provided and only download from trusted sources to avoid security risks.

Installation Process

Once you’ve downloaded the .deb file, installation is straightforward using dpkg:

sudo dpkg -i package-name_version_arch.deb

For example:

sudo dpkg -i curl_7.68.0-1ubuntu2_amd64.deb

If the installation encounters dependency problems, which is common with this method, you can resolve them with:

sudo apt -f install

This command attempts to install any missing dependencies required by the package you’re installing.

Advantages and Limitations

The dpkg method offers precise control over which package file gets installed, bypassing repository constraints. This is particularly useful for older versions no longer available in current repositories or for custom-built packages.

However, this approach has significant limitations. Manual dependency resolution can become complex, especially with packages that have numerous dependencies. Additionally, dpkg installations don’t automatically integrate with APT’s version tracking, potentially leading to conflicts during future system updates.

Use dpkg for isolated applications or when APT-based methods aren’t viable. For system components or frequently updated packages, APT-based installation is generally safer and more sustainable.

Method 3: Using PPAs for Version Control

Personal Package Archives (PPAs) offer another approach to accessing specific package versions not available in standard Ubuntu repositories.

Understanding PPAs

PPAs are user-maintained repositories that can contain newer, older, or modified versions of packages. They’re hosted on Launchpad, Ubuntu’s development platform, and are typically created by developers or enthusiasts to share their software or package versions.

Each PPA has its own web page with information about included packages and versions. For example, the PHP team maintains PPAs with different PHP versions at https://launchpad.net/~ondrej/+archive/ubuntu/php.

Adding and Using PPAs

To add a PPA to your system:

sudo add-apt-repository ppa:username/ppa-name
sudo apt update

For instance, to add a PPA with multiple Python versions:

sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

After adding the PPA, you can install specific versions using the standard APT installation method:

sudo apt install python3.8=3.8.10-0ubuntu1~20.04

Some PPAs are version-specific, containing packages built only for certain Ubuntu releases. Always verify compatibility before adding a PPA to your system.

Risks and Considerations

While PPAs are convenient, they come with important security considerations. Unlike official repositories, PPAs are not thoroughly vetted by the Ubuntu security team. Adding a PPA means trusting its maintainer with system-level access during package installation.

Only add PPAs from reputable sources with active maintenance. Research the PPA maintainer and check community feedback before proceeding. For production systems, limit PPA usage to essential cases and prefer officially supported packages when possible.

Advanced Techniques for Specific Use Cases

Some situations require more advanced approaches to package version management, especially for development environments or highly specialized requirements.

Building Packages from Source

When no pre-built package of the version you need exists, compiling from source code becomes necessary. This approach gives you maximum flexibility in version selection and configuration options.

A basic workflow for building a package from source:

1. Install build dependencies:

   sudo apt install build-essential checkinstall
   sudo apt build-dep package-name

2. Download the source code for your desired version from the official project repository or website
3. Extract and navigate to the source directory:

   tar -xf package-version.tar.gz
   cd package-version/

4. Configure, build, and install:

   ./configure
   make
   sudo checkinstall

Using checkinstall instead of make install creates a .deb package from your compiled source, making it easier to manage or remove later. This approach is particularly valuable for developers who need bleeding-edge features or specific patches not yet available in packaged versions.

Using Docker for Version Isolation

For development environments or testing, Docker containers provide excellent isolation for running specific software versions without affecting your main system.

To use Docker for package version isolation:

1. Install Docker:

   sudo apt install docker.io

2. Create a Dockerfile specifying your required package version:

   FROM ubuntu:20.04
   RUN apt update && apt install -y nginx=1.18.0-0ubuntu1
   EXPOSE 80
   CMD ["nginx", "-g", "daemon off;"]

3. Build and run the container:

   docker build -t nginx-specific .
   docker run -p 8080:80 nginx-specific

This approach is ideal for development environments where maintaining consistent dependencies across team members is critical. It also facilitates testing applications with different versions of their dependencies without risking system stability.

Troubleshooting Common Issues

Even with careful planning, installing specific package versions can sometimes encounter difficulties. Here are solutions to common problems you might face.

Dependency Conflicts

The most frequent issue is dependency conflicts, where your desired version requires libraries that conflict with other installed packages. When you see errors like “package has unmet dependencies” or “broken packages,” try these approaches:

1. Temporarily install required dependencies:

   sudo apt install package-dep=specific-version

2. Use apt’s fix broken option:

   sudo apt -f install

3. Consider using equivs to create dummy packages that satisfy dependencies without installing the actual package:

   sudo apt install equivs
   equivs-control mypackage
   # Edit mypackage file
   equivs-build mypackage
   sudo dpkg -i mypackage_1.0_all.deb

For complex dependency issues, examining the full dependency chain with apt-cache depends package-name can help identify the specific conflict points.

Repository Issues

Sometimes, the version you need exists but isn’t in your configured repositories:

1. For versions from older Ubuntu releases, consider adding the old release repository (with caution):

   sudo nano /etc/apt/sources.list.d/old-release.list
   # Add: deb http://old-releases.ubuntu.com/ubuntu/ xenial main
   sudo apt update

2. For EOL (End of Life) Ubuntu versions, update repository URLs to use old-releases.ubuntu.com instead of archive.ubuntu.com
3. Use apt-pinning to control which repositories are preferred for different packages:

   sudo nano /etc/apt/preferences.d/pin-repository

   Add content like:

   Package: *
   Pin: release n=xenial
   Pin-Priority: 200
   
   Package: nginx
   Pin: release n=xenial
   Pin-Priority: 600

Remember to remove or update these special repository configurations after installing your specific package to avoid potential system instability.

Installation Failures

When installation completely fails, these strategies often help:

1. Clear APT cache and try again:

   sudo apt clean
   sudo apt update

2. Check for conflicting packages:

   dpkg -l | grep package-name

3. Temporarily remove conflicting packages, install your specific version, then reinstall the removed packages:

   sudo apt remove conflicting-package
   sudo apt install package-name=specific-version
   sudo apt install conflicting-package

Always make a backup or system snapshot before attempting complex package manipulation, especially on production systems.

Real-World Examples

Let’s examine some practical scenarios where installing specific package versions is necessary:

WordPress Development Environment

A developer needs to set up a local environment that matches their production server with PHP 7.4 instead of the newer PHP 8.0 that comes with their Ubuntu version:

sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php7.4=7.4.28-1+ubuntu20.04.1+deb.sury.org+1
sudo apt install php7.4-{cli,common,curl,json,mbstring,mysql,xml,zip}
sudo apt-mark hold php7.4

Security Patching an Older MySQL Version

A sysadmin needs to apply a security patch to MySQL 5.7 without upgrading to MySQL 8.0:

# Check current version
mysql --version
# Pin MySQL to 5.7 series
echo -e "Package: mysql-server\nPin: version 5.7.*\nPin-Priority: 1001" | sudo tee /etc/apt/preferences.d/mysql
# Update and upgrade only MySQL
sudo apt update && sudo apt install mysql-server

Downgrading After a Problematic Update

After a problematic update breaks functionality in the Apache web server, reverting to the previous working version:

# Check previously installed version
dpkg -l | grep apache2
# Downgrade to the specific version
sudo apt install apache2=2.4.41-4ubuntu3
# Prevent further automatic updates
sudo apt-mark hold apache2

These real-world examples demonstrate how version-specific installation techniques apply to common scenarios faced by developers and system administrators.