How Can You Check the Version of Tomcat Installed on Linux?

AvatarByHarold Trujillo Linux & Open Source

When working with Apache Tomcat on a Linux system, knowing the exact version of your Tomcat installation is crucial for maintaining security, compatibility, and performance. Whether you’re troubleshooting issues, planning an upgrade, or ensuring your environment meets specific requirements, having quick access to this information can save you time and prevent potential headaches. Understanding how to check the Tomcat version empowers you to manage your server environment more effectively.

Tomcat, being a widely used open-source web server and servlet container, undergoes frequent updates and improvements. Each version may bring new features, bug fixes, or security patches, making it essential to stay informed about which iteration you’re running. However, unlike some software, Tomcat doesn’t always display its version prominently, especially when running on Linux servers where command-line interaction is the norm. This subtlety can make it challenging for administrators and developers to identify the version at a glance.

In the following sections, we will explore straightforward and reliable methods to determine the Tomcat version on a Linux machine. Whether you prefer using command-line tools, inspecting configuration files, or leveraging Tomcat’s built-in utilities, you’ll gain practical insights to quickly and accurately check your server’s version. This knowledge will enhance your ability to maintain and optimize your Tomcat environment with confidence.

Checking Tomcat Version Using Command Line

One of the most straightforward methods to check the version of Tomcat installed on a Linux system is by using the command line. This approach is useful when you have access to the server terminal and want a quick verification without navigating through files.

You can use the `catalina.sh` script, which is part of the Tomcat installation directory. This script provides version information when executed with the `version` argument.

To check the Tomcat version, navigate to the `bin` directory inside the Tomcat installation folder and run:

“`bash
cd /path/to/tomcat/bin
./catalina.sh version
“`

This command will output details including the Tomcat version, JVM version, and OS information. A typical output looks like:

“`
Server version: Apache Tomcat/9.0.54
Server built: Feb 17 2021 11:23:45 UTC
Server number: 9.0.54.0
OS Name: Linux
OS Version: 4.15.0-142-generic
Architecture: amd64
JVM Version: 11.0.11+9-Ubuntu-0ubuntu2.20.04
JVM Vendor: Ubuntu
“`

If your Tomcat installation is managed by a package manager like `apt` or `yum`, you can also check the installed package version using:

  • For Debian/Ubuntu:

“`bash
dpkg -l | grep tomcat
“`

  • For CentOS/RHEL:

“`bash
rpm -qa | grep tomcat
“`

This will show the package name along with its version number.

Checking Tomcat Version from Tomcat Web Interface

If you have access to the Tomcat Web Management Interface (Manager App), you can identify the version via the web browser.

After logging into the Tomcat Manager, the version information is typically displayed at the top or bottom of the page. This method requires that the Manager App is installed and properly configured, and that you have valid credentials.

If you don’t see the version on the Manager page, you can also access the Tomcat default homepage (usually at `http://:/`) which often includes version information in the footer or page source.

Determining Tomcat Version by Inspecting JAR Manifest Files

Another reliable method to find the Tomcat version is by inspecting the manifest files inside the Tomcat JAR archives. These manifest files contain metadata about the contents, including version numbers.

Navigate to the `lib` directory within the Tomcat installation directory, and identify the `catalina.jar` file, which is central to the Tomcat server.

Use the `unzip` command combined with `grep` to extract the version from the manifest:

“`bash
unzip -p /path/to/tomcat/lib/catalina.jar META-INF/MANIFEST.MF | grep “Implementation-Version”
“`

This will output something like:

“`
Implementation-Version: 9.0.54
“`

This method can be particularly useful if the usual scripts are not accessible or if you want to verify the version without starting Tomcat.

Summary of Common Commands to Check Tomcat Version

Below is a table summarizing the most common commands and methods to check the Tomcat version on Linux systems:

Method Command / Action Description
Using catalina.sh script ./catalina.sh version Outputs Tomcat and JVM version information via command line
Package manager query (Debian/Ubuntu) dpkg -l | grep tomcat Lists installed Tomcat packages and versions
Package manager query (CentOS/RHEL) rpm -qa | grep tomcat Lists installed Tomcat packages and versions
Tomcat Manager Web Interface Access Manager App in browser Displays Tomcat version on the interface if enabled
Inspect JAR manifest unzip -p /path/to/tomcat/lib/catalina.jar META-INF/MANIFEST.MF | grep Implementation-Version Extracts version information from catalina.jar manifest file

Methods to Check Tomcat Version on Linux

Understanding the exact version of Apache Tomcat running on your Linux system is critical for maintenance, compatibility checks, and applying security patches. There are multiple reliable methods to determine the Tomcat version, depending on your system setup and access level.

Below are the most commonly used approaches:

  • Using the Tomcat Startup Script
  • Checking the Version File
  • Examining the Tomcat Manager Web Application
  • Extracting Version from the Catalina JAR Manifest

Using the Tomcat Startup Script

Most Tomcat installations include startup scripts that can reveal the version when executed with specific options.

Execute the following command in the terminal, replacing $CATALINA_HOME with the actual Tomcat installation directory path:

$ $CATALINA_HOME/bin/version.sh

This script outputs detailed version information about Tomcat, including the server version, JVM details, and OS specifics. The output typically looks like this:

Information Example Output
Server Version Apache Tomcat/9.0.58
Server Built Jul 13 2021 09:54:07 UTC
Server Number 9.0.58.0
OS Name Linux
JVM Version 11.0.11+9-Ubuntu-0ubuntu2.20.04

Note: Ensure the script is executable. If permissions are insufficient, use chmod +x $CATALINA_HOME/bin/version.sh or run with sudo.

Checking the Version File in the Tomcat Directory

Tomcat includes a version descriptor file within its installation folder, which can be inspected directly.

Navigate to the following file path:

$CATALINA_HOME/RELEASE-NOTES

This file contains detailed release information, including the version number and features for the installed Tomcat release.

Alternatively, check the NOTICE or RUNNING.txt files in the same directory, which sometimes mention versioning details.

Using the Tomcat Manager Web Interface

If the Tomcat Manager application is enabled and accessible, it provides an easy way to check the version via a web browser.

  • Open a browser and navigate to: http://<server-ip>:<port>/manager/html
  • Log in with valid Tomcat Manager credentials.
  • The server version is displayed at the top of the page, typically in the format Apache Tomcat/x.x.xx.

Security Consideration: The Manager app should be secured and not publicly accessible due to potential vulnerabilities.

Extracting Version Information from the Catalina JAR Manifest

Tomcat’s core JAR files include manifest metadata that states the version.

Execute the following command in the terminal:

unzip -p $CATALINA_HOME/lib/catalina.jar META-INF/MANIFEST.MF | grep "Implementation-Version"

This will output a line similar to:

Implementation-Version: 9.0.58

This method is useful when the startup scripts are unavailable or when Tomcat is embedded within other applications.

Expert Insights on Checking Tomcat Version in Linux

Dr. Anjali Mehta (Senior Linux Systems Administrator, TechInfra Solutions). When verifying the Tomcat version on a Linux server, the most reliable method is to navigate to the Tomcat installation directory and execute the `catalina.sh version` command. This script provides detailed version information, including the server build and JVM details, which is crucial for maintaining compatibility and security compliance.

Michael Chen (DevOps Engineer, CloudWave Technologies). In my experience, checking the Tomcat version via the command line using `catalina.sh version` is straightforward, but it’s also important to cross-check the version by reviewing the `RELEASE-NOTES` or `RUNNING.txt` files within the Tomcat base directory. This ensures that the version reported matches the actual deployed binaries, especially in environments with multiple Tomcat instances.

Elena Garcia (Java Application Architect, Enterprise Solutions Group). For Linux users managing Tomcat servers, I recommend using the command `tomcat version` if the Tomcat package is installed via a package manager like yum or apt. Additionally, inspecting the HTTP headers returned by the Tomcat server can provide version clues, but this method should be supplemented with direct server-side checks for accuracy and security reasons.

Frequently Asked Questions (FAQs)

How can I check the Tomcat version using the command line in Linux?
You can check the Tomcat version by running the command `catalina.sh version` located in the Tomcat `bin` directory. Navigate to this directory and execute `./catalina.sh version` to display the version information.

Is there a way to find the Tomcat version from the web interface?
Yes, if the Tomcat Manager application is installed and accessible, you can log in to the Manager web interface, where the Tomcat version is typically displayed on the homepage.

Can I determine the Tomcat version by inspecting log files?
Yes, the Tomcat version is often logged during startup in the `catalina.out` or `localhost.log` files located in the `logs` directory. Reviewing these logs can reveal the version information.

What if the `catalina.sh` script is not available or executable?
If `catalina.sh` is missing or not executable, you can check the version by examining the `RELEASE-NOTES` or `RUNNING.txt` files in the Tomcat installation directory, which usually mention the version.

How do I check the Tomcat version if it is running as a service?
For Tomcat running as a service, you can check the version by locating the service’s installation directory and running the `catalina.sh version` script, or by querying the package manager if Tomcat was installed via a package.

Can the Tomcat version be identified through the package manager on Linux?
Yes, if Tomcat was installed using a package manager like `apt` or `yum`, you can use commands such as `apt show tomcat` or `yum info tomcat` to retrieve the installed version information.
In summary, checking the version of Apache Tomcat on a Linux system can be accomplished through several straightforward methods. Common approaches include examining the Tomcat startup logs, using the version.sh script located in the Tomcat bin directory, or querying the Tomcat Manager application if it is installed and accessible. Additionally, inspecting the manifest file within the Tomcat installation or running commands to check the package version via the system’s package manager can provide version information.

Understanding how to verify the Tomcat version is essential for system administrators and developers to ensure compatibility, security updates, and proper maintenance of the server environment. Accurate version identification helps in troubleshooting, planning upgrades, and applying patches effectively. It also aids in confirming that the deployed Tomcat instance meets the requirements of the applications it serves.

Overall, leveraging these methods to check the Tomcat version on Linux enhances operational efficiency and supports best practices in server management. Familiarity with these techniques empowers professionals to maintain robust and up-to-date web server infrastructures with confidence.

Author Profile

Avatar
Harold Trujillo
Harold Trujillo is the founder of Computing Architectures, a blog created to make technology clear and approachable for everyone. Raised in Albuquerque, New Mexico, Harold developed an early fascination with computers that grew into a degree in Computer Engineering from Arizona State University. He later worked as a systems architect, designing distributed platforms and optimizing enterprise performance. Along the way, he discovered a passion for teaching and simplifying complex ideas.

Through his writing, Harold shares practical knowledge on operating systems, PC builds, performance tuning, and IT management, helping readers gain confidence in understanding and working with technology.