Integrating Tomcat and Apache on RedHat 9 LG #95

Java servlets are a powerful tool for building websites and web based applications. One skill that every Java web developer should have is the ability to install and configure the Tomcat servlet engine. Many thanks to the Apache Software Foundation for providing this mature, stable, open source software. It was recently voted the Best Application Server of 2003 by InfoWorld readers.

This article discusses how to integrate Tomcat with the Apache web server on RedHat 9.0. The goal is to provide a simple, stable configuration that will allow users to gain confidence using Tomcat.

Installing Apache

I chose to install Apache using the RedHat RPM. Using the RPM instead of compiling Apache from source simplifies system administration in the following ways:

I recommend using the RedHat up2date command line utility to install RedHat RPMs. Although up2date can be used without purchasing a RedHat Network subscription, a basic subscription is a great value. It eliminates a multitude of headaches by ensuring the software you install is the correct version and you have the right dependencies installed on your system.

To install these packages using up2date, make sure you are connected to the Internet, and enter the following:

up2date -i httpd
up2date -i httpd-devel

service httpd start
service httpd stop
service httpd restart

Verify that Apache is working by starting Apache and typing https://localhost/ into your browser. You should see the default Apache install page with links to documentation.

Installing Tomcat

The only requirements to run Tomcat are that a Java Development Kit (JDK), also called a Java Software Developement Kit (SDK), be installed and the JAVA_HOME environment variable be set.

Java SDK

I chose to install Sun's Java 2 Platform, Standard Edition, which can be downloaded from https://java.sun.com/j2se/). I chose the J2SE v1.4.2 SDK Linux self-extracting binary file.

Change to the directory where you downloaded the SDK and make the self-extracting binary executable:

chmod +x j2sdk-1_4_2-linux-i586.bin

./j2sdk-1_4_2-linux-i586.bin

There should now be a directory called j2sdk1.4.2 in the download directory. Move the SDK directory to where you want it to be installed. I chose to install it in /usr/java. Create /usr/java if it doesn't exist. Here is the command I used from inside the download directory:

mv j2sdk1.4.2 /usr/java

Set the JAVA_HOME environment variable, by modifying /etc/profile so it includes the following:

JAVA_HOME="usr/java/j2sdk1.4.2"
export JAVA_HOME

There will be other environment variables being set in /etc/profile, so you will probably be adding JAVA_HOME to an existing export command. /etc/profile is run at startup and when a user logs into a system.

Tomcat Account

You will install and configure Tomcat as root; however, you should create a group and user account for Tomcat to run under as follows:

groupadd tomcat
useradd -g tomcat tomcat

This will create the /home/tomcat directory, where I will install my Tomcat applications.

Download Tomcat

There are a number of different download formats. I chose the LE version gnu zipped tar file (jakarta-tomcat-4.1.27-LE-jdk14.tar.gz).

Tomcat Standalone

tar xvzf tomcat-4.1.27-LE-jdk14.tar.gz

This will create a directory called jakarta-tomcat-4.1.27-LE-jdk14. Move this directory to wherever you would like to install Tomcat. I chose /usr/local. Here is the command I issued from inside the download directory:

mv jakarta-tomcat-4.1.27-LE-jdk14 /usr/local/

The directory where Tomcat is installed is referred to as CATALINA_HOME in the Tomcat documentation. In this case CATALINA_HOME=/usr/local/jakarta-tomcat-4.1.27-LE-jdk14.

I recommend setting up a symbolic link to point to your current Tomcat version. This will save you from having to change your startup and shutdown scripts each time you upgrade Tomcat or set a CATALINA_HOME environment variable. It also allows you to keep several versions of Tomcat on your system and easily switch amongst them. Here is the command I issued from inside /usr/local to create a symbolic link called /usr/local/jakarta-tomcat that points to /usr/local/jakarta-tomcat-4.1.27-LE-jdk14:

ln -s jakarta-tomcat-4.1.27-LE-jdk14 jakarta-tomcat

Change the group and owner of the /usr/local/jakarta-tomcat and /usr/local/jakarta-tomcat-4.1.27-LE-jdk14 directories to tomcat:

chown tomcat.tomcat /usr/local/jakarta-tomcat
chown -R tomcat.tomcat /usr/local/jakarta-tomcat-4.1.27-LE-jdk14

It is not necessary to set the CATALINA_HOME environment variable. Tomcat is smart enough to figure out CATALINA_HOME on its own.

You should now be able to start and stop Tomcat from the CATALINA_HOME/bin directory by typing ./startup.sh and ./shutdown.sh respectively. Test that Tomcat is working by starting it and typing https://localhost:8080 into your browser. You should see the Tomcat welcome page with links to documentation and sample code. Verify Tomcat is working by clicking on some of the examples links.

Selecting A Connector

At this point, Apache and Tomcat should be working separately in standalone mode. You can run Tomcat in standalone mode as an alternative to Apache. In fact, in some cases, it is said that Tomcat standalone is faster than serving static content from Apache and dynamic content from Tomcat. However, there are compelling reasons to use Apache as the front end. If you run Tomcat standalone:

I think the increased functionality obtained by using Apache on the front end far outweighs the effort required to install and configure a connector. With that said, I selected the tried and true mod_jk connector. It has been around a long while and is very stable. mod_jk2 is the wave of the future, but I'm holding off on that for now. In early 2002 I invested a considerable amount of time on the "wave of the future" connector at that time, mod_webapp, which is now no longer being developed. For that reason, I am being cautious about migrating to mod_jk2.

Building the mod_jk Connector

The mod_jk connector is the communication link between Apache and Tomcat. It listens on port 8009 for requests from Apache.

In my experience, it's safest to think of connectors as being version dependent. If you upgrade Tomcat and you have a connector issue, try compiling the connector using the version-specific connector source.

Download the connector source for your version of Tomcat from https://www.apache.org/dist/jakarta/tomcat-4/source/. I used jakarta-tomcat-connectors-4.1.27-src.tar.gz. The source for all the different connectors (mod_jk, mod_jk2, coyote, etc.) is distributed in this one file.

tar xvzf jakarta-tomcat-connectors-4.1.27-src.tar.gz

This will create a folder called jakarta-tomcat-connectors-4.1.27-src. Move this folder to wherever you store source files on your system. I chose /usr/src. Here is the command I issued from inside the download directory:

mv jakarta-tomcat-connectors-4.1.27-src /usr/src/

I refer to the folder where the connector source is installed as CONN_SRC_HOME. In my case CONN_SRC_HOME = /usr/src/jakarta-tomcat-connectors-4.1.27-src.

Run the buildconf script to to create the CONN_SRC_HOME/jk/native/configure file.

CONN_SRC_HOME/jk/native/buildconf.sh

Run the configure script with the path to the apxs file on your system and the options below:

./configure --with-apxs=/usr/sbin/apxs

If all went well, the mod_jk.so file was successfully created. Manually copy it to Apache's shared object files directory:

cp CONN_SRC_HOME/jk/native/apache-2.0/mod_jk.so /etc/httpd/modules

Configuring Tomcat

workers.properties

The workers.properties file contains information so mod_jk can connect to the Tomcat worker processes.

Create a directory called CATALINA_HOME/conf/jk and place the workers.properties file found in the Appendix in this directory.

server.xml

The server.xml file contains Tomcat server configuration information. The default CATALINA_HOME/conf/server.xml file that comes with Tomcat contains so much information that I recommend saving it for future reference (e.g. server.xml.bak) and starting from scratch. The default server.xml is great for verifying that Tomcat works in standalone mode and for viewing the examples that come with the application, but I have found it is not the best starting point when you want to integrate Apache with Tomcat. Instead, create a bare bones server.xml file as follows:

<Server port="8005" shutdown="SHUTDOWN" debug="0">

	<Service name="Tomcat-Apache">

		<Connector className="org.apache.ajp.tomcat.Ajp13Connector"
			port="8009" minProcessors="5" maxProcessors="75" 
			acceptCount="10" debug="0"/>   

		<Engine name="your_engine" debug="0" defaultHost="your_domain.com">
			<Logger className="org.apache.catalina.logger.FileLogger"
				prefix="apache_log." suffix=".txt" 
				timestamp="true"/>
			<Host name="your_domain" debug="0" appBase="webapps" 
				unpackWARs="true">
				
				<Context path="" docBase="/home/tomcat/your_application" 
				debug="0" reloadable="true" />
				
			</Host>
		</Engine>

	</Service>

</Server>

Configuring Apache

httpd.conf

Apache is configured with directives placed in the Apache configuration file, /etc/httpd/conf/httpd.conf. You will notice that there are three sections labeled in the httpd.conf file supplied by RedHat: (1) Global Environment, (2) Main Server Configuration, and (3) Virtual Hosts.

Add the following to the bottom of the existing LoadModule directives in the Global Environment section:

LoadModule jk_module modules/mod_jk.so

Add the following to the bottom of the existing AddModule directives in the Global Environment section:

JkWorkersFile "/usr/local/jakarta-tomcat/conf/jk/workers.properties"
JkLogFile "/usr/local/jakarta-tomcat/logs/mod_jk.log"
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"

The configuration above assumes you created a symbolic link /usr/jakarta-tomcat that points to the directory where your version of Tomcat is installed.

Set up a Virtual Host directive in the Virtual Hosts section of httpd.conf. Below is an example of how to set up the your_domain website to forward all URLs with "servlet" in the path to Tomcat:

NameVirtualHost *:80

<VirtualHost 192.168.1.1>
	ServerAdmin webmaster@your_domain
	ServerName your_domain
	DocumentRoot /home/www/your_domain/html
	ErrorLog /home/www/your_domain/logs/error_log
	CustomLog /home/www/your_domain/logs/access_log common
	JkMount /servlet/* ajp13
</VirtualHost>

The configuration above assumes that your application's static html files will be served from the /home/www/your_domain/html directory.

apachectl configtest

Setting Up your_domain

your_domain.com does not need to be a domain name with a DNS entry. For testing purposes, you can set up any domain you want in the /etc/hosts file of the machine that you will be using to access your_application.

The example below shows the entry for your_domain when running Apache and Tomcat on a single machine, typical for a development computer.

127.0.0.1	your_domain

Testing

We will now create and install a simple Hello World servlet so we can test our setup.

Hello World Servlet

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld
    extends HttpServlet {
    public void doGet(HttpServletRequest request, 
                       HttpServletResponse response)
                throws IOException, ServletException {
		
		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		
		out.println("Hello World");

	}

}

javac -classpath /usr/java/jakarta-tomcat/common/lib/servlet.jar HelloWorld.java

Tomcat Application

/home/tomcat/your_application/WEB_INF
/home/tomcat/your_application/WEB_INF/classes
/home/tomcat/your_application/WEB_INF/web.xml

The web.xml file is where you map the name of your servlet to a URL pattern so Tomcat can run your servlet when requested. Below is the web.xml file that runs the HelloWorld servlet whenever the URL https://your_domain/servlet/HelloWorld is entered in the browser:

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "https://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

	<servlet>
		<servlet-name>HelloWorld</servlet-name>
		<servlet-class>HelloWorld</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>HelloWorld</servlet-name>
		<url-pattern>/servlet/HelloWorld</url-pattern>
	</servlet-mapping>
                
</web-app>

Copy the HelloWorld.class file to the /tomcat/home/your_application/WEB-INF/classes directory.

/CATALINA_HOME/bin/shutdown.sh
/CATALINA_HOME/bin/startup.sh

service httpd restart

You should now be able to type https://your_domain/servlet/HelloWorld into your browser and see the always-exciting "Hello World" message.

Advanced Configuration

The following steps are not mandatory, but are suggested for a better, tighter Tomcat installation.

Tomcat Startup Script

If you want to automatically start Tomcat when your system boots and manage it using the service command as we do Apache, you must create an initialization script.

#!/bin/sh
#
# Startup script for Tomcat, the Apache Servlet Engine
#
# chkconfig: 345 80 20
# description: Tomcat is the Apache Servlet Engine
# processname: tomcat
# pidfile: /var/run/tomcat.pid
#
# Mike Millson <mmillson@meritonlinesystems.com>
#
# version 1.02 - Clear work directory on shutdown per John Turner suggestion.
# version 1.01 - Cross between RedHat Tomcat RPM and Chris Bush scripts

# Tomcat name :)
TOMCAT_PROG=tomcat
 
# if TOMCAT_USER is not set, use tomcat like Apache HTTP server
if [ -z "$TOMCAT_USER" ]; then
 TOMCAT_USER="tomcat"
fi

RETVAL=0

# start and stop functions
start() {
    echo -n "Starting tomcat: "

    chown -R $TOMCAT_USER:$TOMCAT_USER /usr/local/jakarta-tomcat/*    
    chown -R $TOMCAT_USER:$TOMCAT_USER /home/tomcat/*
    su -l $TOMCAT_USER -c '/usr/local/jakarta-tomcat/bin/startup.sh'
    RETVAL=$?
    echo
    [ $RETVAL = 0 ] && touch /var/lock/subsys/tomcat
    return $RETVAL
}

stop() {
    echo -n "Stopping tomcat: "
    su -l $TOMCAT_USER -c '/usr/local/jakarta-tomcat/bin/shutdown.sh'
    RETVAL=$?
    Echo
    [ $RETVAL = 0 ] && rm -f /var/lock/subsys/tomcat /var/run/tomcat.pid    
    rm -rf /usr/local/jakarta-tomcat/work/*
}

# See how we were called.
case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  restart)
        stop
	# Ugly hack
	# We should really make sure tomcat
	# is stopped before leaving stop
        sleep 2	
        start
        ;;
  *)
	echo "Usage: $0 {start|stop|restart}"
	exit 1
esac

exit $RETVAL

chkconfig --add tomcat

service tomcat start
service tomcat stop
service tomcat restart

If you want Tomcat to start automatically when your system boots, you need to add tomcat to your runlevel as follows:

chkconfig --level 5 tomcat on

Runlevel 5 is the X Window System, typical for a development computer. Runlevel 3 is typical for a dedicated web server.

The start order of Apache and Tomcat is very important. Tomcat must be started before you start Apache so Apache can attach itself to the Tomcat processes.

Development Setup

During development, you will need access to your tomcat application directory. Add the user account under which you will be doing development to the tomcat group in /etc/group. For example, this is what the tomcat entry might look like in /etc/group if you do development under the

tomcat:x:502:yourname

Make sure the tomcat group has write permission to /home/tomcat so you can publish files (e.g. using ant) to your Tomcat application in /home/tomcat/your_application. Issue the following command as root:

chmod g+w /home/tomcat

Appendix

workers.properties

# workers.properties
#
# This file provides jk derived plugins with the needed information to
# connect to the different tomcat workers.  Note that the distributed
# version of this file requires modification before it is usable by a
# plugin.
#
# As a general note, the characters $( and ) are used internally to define
# macros. Do not use them in your own configuration!!!
#
# Whenever you see a set of lines such as:
# x=value
# y=$(x)\something
#
# the final value for y will be value\something
#
# Normaly all you will need to do is un-comment and modify the first three
# properties, i.e. workers.tomcat_home, workers.java_home and ps.
# Most of the configuration is derived from these.
#
# When you are done updating workers.tomcat_home, workers.java_home and ps
# you should have 3 workers configured:
#
# - An ajp12 worker that connects to localhost:8007
# - An ajp13 worker that connects to localhost:8009
# - A jni inprocess worker.
# - A load balancer worker
#
# However by default the plugins will only use the ajp12 worker. To have
# the plugins use other workers you should modify the worker.list property.
#
# OPTIONS ( very important for jni mode )
#
# workers.tomcat_home should point to the location where you
# installed tomcat. This is where you have your conf, webapps and lib
# directories.
#
workers.tomcat_home=/usr/local/jakarta-tomcat
#
# workers.java_home should point to your Java installation. Normally
# you should have a bin and lib directories beneath it.
#
workers.java_home=$(JAVA_HOME)
#
# You should configure your environment slash... ps=\ on NT and / on UNIX
# and maybe something different elsewhere.
#
ps=/
#
#------ ADVANCED MODE ------------------------------------------------
#---------------------------------------------------------------------
#
#------ DEFAULT worket list ------------------------------------------
#---------------------------------------------------------------------
#
# The workers that your plugins should create and work with
#
worker.list=ajp12, ajp13
#
#------ DEFAULT ajp12 WORKER DEFINITION ------------------------------
#---------------------------------------------------------------------
#
#
# Defining a worker named ajp12 and of type ajp12
# Note that the name and the type do not have to match.
#
worker.ajp12.port=8007
worker.ajp12.host=localhost
worker.ajp12.type=ajp12
#
# Specifies the load balance factor when used with
# a load balancing worker.
# Note:
#  ----> lbfactor must be > 0
#  ----> Low lbfactor means less work done by the worker.
worker.ajp12.lbfactor=1
#
#------ DEFAULT ajp13 WORKER DEFINITION ------------------------------
#---------------------------------------------------------------------
#
# Defining a worker named ajp13 and of type ajp13
# Note that the name and the type do not have to match.
#
worker.ajp13.port=8009
worker.ajp13.host=localhost
worker.ajp13.type=ajp13
#
# Specifies the load balance factor when used with
# a load balancing worker.
# Note:
#  ----> lbfactor must be > 0
#  ----> Low lbfactor means less work done by the worker.
worker.ajp13.lbfactor=1
#
# Specify the size of the open connection cache.
#worker.ajp13.cachesize
#
#------ DEFAULT LOAD BALANCER WORKER DEFINITION ----------------------
#---------------------------------------------------------------------
#
# The loadbalancer (type lb) workers perform wighted round-robin
# load balancing with sticky sessions.
# Note:
#  ----> If a worker dies, the load balancer will check its state
#        once in a while. Until then all work is redirected to peer
#        workers.
worker.loadbalancer.type=lb
worker.loadbalancer.balanced_workers=ajp12, ajp13
#
#------ DEFAULT JNI WORKER DEFINITION---------------------------------
#---------------------------------------------------------------------
#
# Defining a worker named inprocess and of type jni
# Note that the name and the type do not have to match.
#
worker.inprocess.type=jni
#
#------ CLASSPATH DEFINITION -----------------------------------------
#---------------------------------------------------------------------
#
# Additional class path components.
#
worker.inprocess.class_path=$(workers.tomcat_home)$(ps)lib$(ps)tomcat.jar
#
# Setting the command line for tomcat.
# Note: The cmd_line string may not contain spaces.
#
worker.inprocess.cmd_line=start
#
# Not needed, but can be customized.
# worker.inprocess.cmd_line=-config
# worker.inprocess.cmd_line=$(workers.tomcat_home)$(ps)conf$(ps)server.xml
# worker.inprocess.cmd_line=-home
# worker.inprocess.cmd_line=$(workers.tomcat_home)
#
# The JVM that we are about to use
#
# This is for Java2
#
# Windows
# #worker.inprocess.jvm_lib=$(workers.java_home)$(ps)jre$(ps)bin$(ps)classic$(ps)jvm.dll
# IBM JDK1.3
# worker.inprocess.jvm_lib=$(workers.java_home)$(ps)jre$(ps)bin$(ps)classic$(ps)libjvm.so
# Unix - Sun VM or blackdown
#worker.inprocess.jvm_lib=$(workers.java_home)$(ps)jre$(ps)lib$(ps)i386$(ps)classic$(ps)libjvm.so
# RH + JDK1.4
worker.inprocess.jvm_lib=$(workers.java_home)$(ps)jre$(ps)lib$(ps)i386$(ps)server$(ps)libjvm.so
#
# And this is for jdk1.1.X
#
# worker.inprocess.jvm_lib=$(workers.java_home)$(ps)bin$(ps)javai.dll
#
# Setting the place for the stdout and stderr of tomcat
#
worker.inprocess.stdout=$(workers.tomcat_home)$(ps)logs$(ps)inprocess.stdout
worker.inprocess.stderr=$(workers.tomcat_home)$(ps)logs$(ps)inprocess.stderr
#
# Setting the tomcat.home Java property
#
# worker.inprocess.sysprops=tomcat.home=$(workers.tomcat_home)
#
# Java system properties
#
# worker.inprocess.sysprops=java.compiler=NONE
# worker.inprocess.sysprops=myprop=mypropvalue
#
# Additional path components.
#
# worker.inprocess.ld_path=d:$(ps)SQLLIB$(ps)bin

Integrating Tomcat and Apache on RedHat 9.0

Introduction

Installing Apache

Installing Tomcat

Java SDK

Tomcat Account

Download Tomcat

Tomcat Standalone

Selecting A Connector

Building the mod_jk Connector

Configuring Tomcat

workers.properties

server.xml

Configuring Apache

httpd.conf

Setting Up your_domain

Testing

Hello World Servlet

Tomcat Application

Advanced Configuration

Tomcat Startup Script

Development Setup

Appendix

workers.properties

Related Linux Gazette Articles

Bio