Configure linux web server step by step guide example and implementation

Apache Tomcat Server

Index

• Installation
  • Setup First Instance
  • Setup WEB application
  • Setup Java Servlet for WEB application
• Setup Second Instance
  • Setup WEB application
  • Setup Java Servlet for WEB application
• Tomcat Cluster(Load Balance)using mod_jk

Today,I am going to discuss about the tomcat server with examples.Whatever I understood so far will be covered here.
I am going to install tomcat server,then will create multiple instance of it and then will deploy the web contents and so on..
Whatever I have/will learned/learn will put it here.

Installation

Installing JRE
To run Tomcat, you need Java Standard Edition (Java SE), also known as the JDK.You can download SUN's latest Java JDKs at: http://java.sun.com/javase/downloads/index.jsp
On RHEL Server type below command

#yum install java*

For my 64-bit RHEL box I downloaded the 64-bit JDK multiplatform binary for Linux: jdk-6u10-linux-x64.bin. 
I downloaded the binary file to /tmp and installed it as follows as root:
# mkdir -p /usr/java
# cd /usr/java
#
# chmod 700 /tmp/jdk-6u10-linux-x64.bin
# /tmp/jdk-6u10-linux-x64.bin
...
   creating: jdk1.6.0_10/
   creating: jdk1.6.0_10/db/
   creating: jdk1.6.0_10/db/bin/
  inflating: jdk1.6.0_10/db/bin/ij   
  inflating: jdk1.6.0_10/db/bin/NetworkServerControl  
  inflating: jdk1.6.0_10/db/bin/setNetworkClientCP.bat  
  inflating: jdk1.6.0_10/db/bin/derby_common.sh  
...
Done.
# export JAVA_HOME=/usr/java/jdk1.6.0_10
# export PATH=$JAVA_HOME/bin:$PATH
#
# which java
/usr/java/jdk1.6.0_10/bin/java
# java -version
java version "1.6.0_10"
Java(TM) SE Runtime Environment (build 1.6.0_10-b33)
Java HotSpot(TM) 64-Bit Server VM (build 11.0-b15, mixed mode)

Installing TOMCAT

Download the latest Tomcat 7.x version from http://tomcat.apache.org/download-70.cgi. I downloaded the Binary Core Distribution file apache-tomcat-7.0.30.tar.gz - the latest version at this time.
Installing Tomcat from a binary release (tar file) requires manual creation of the Tomcat user account. This is not necessary if you install the Tomcat RPM package on RHEL.
For security reasons I created a user account with no login shell for running the Tomcat server:

# groupadd venkatadmin
# useradd -g venkatadmin -s /sbin/nologin -m -d /home/venkat venkat

Next I extracted the tar file to /opt/tomcat and changed the ownership of all files and directories to tomcat:

# mkdir /opt/tomcat
# cd /opt/tomcat
# tar zxvf /tmp/apache-tomcat-7.0.30.tar.gz
# chown -R venkat:venkatadmin /opt/tomcat/apache-tomcat-7.0.30

The get the Tomcat version of the newly installed Tomcat, run:

# /opt/tomcat/apache-tomcat-7.0.30/bin/version.sh
Using CATALINA_BASE:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_HOME:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_TMPDIR: /opt/tomcat/apache-tomcat-7.0.30/temp
Using JRE_HOME: /usr
Server version: Apache Tomcat/6.0.18
Server built:   Jul 22 2008 02:00:36
Server number:  6.0.18.0
OS Name:        Linux
OS Version:     2.6.18-6-amd64
Architecture:   x86_64
JVM Version:    1.4.2
JVM Vendor:     Free Software Foundation, Inc.

Starting/Stopping Tomcat

Now startup the Tomcat server to see whether the default Tomcat home page is being displayed. 

For security reasons I don't run the Tomcat server as user root but as venkat which was created with no login shell. 
Therefore, to run Tomcat use the su command with the -p option to preserves all the environment variables when switching to venkat.
And since the venkat account has no login shell, it needs to be specified with the -s option. 
(You may want to use this su command if you plan on writing and implementing a system startup and shutdown script for system reboots.)

# export JAVA_HOME=/usr/java/jdk1.6.0_10
# export PATH=$JAVA_HOME/bin:$PATH
# export CATALINA_HOME=/opt/tomcat/apache-tomcat-7.0.30
# export CATALINA_BASE=/opt/tomcat/apache-tomcat-7.0.30

# su -p -s /bin/sh venkat $CATALINA_HOME/bin/startup.sh
Using CATALINA_BASE:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_HOME:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_TMPDIR: /opt/tomcat/apache-tomcat-7.0.30/temp
Using JRE_HOME:       /usr/java/jdk1.6.0_10


Now try opening the URL http://localhost:8080 (default port 8080) from same servers browser. 
Note that you should also be able to use the name of your server instead of localhost. 
Once you opened the URL in your browser you should see Tomcat's Congratulation page. If you don't see the page, check the log files under $CATALINA_HOME/logs (/opt/tomcat/apache-tomcat-7.0.30/logs). 

To shutdown use below command,

# su -p -s /bin/sh venkat $CATALINA_HOME/bin/shutdown.sh
Using CATALINA_BASE:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_HOME:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_TMPDIR: /opt/tomcat/apache-tomcat-7.0.30/temp
Using JRE_HOME:       /usr/java/jdk1.6.0_10

Switching to nologin shell venkat User Account

Most of the next steps in this article assume that you switched to the venkat user account. If you see a '$' prompt, then the steps in this article are executed as the venkat user. 
If you see a '#' prompt, then the steps are executed as root. 

# su - -s /bin/sh venkat

confirm with the id command,

$ id
uid=1001(venkat) gid=1001(venkatadmin) groups=1001(venkatadmin)


Note that non-root users cannot switch to the venkat account. 

Installation Complete!

Setup First Tomcat Instance

It is recommended not to store the web applications's files in Tomcat's distribution directory tree. 
For example, having a separate directory makes Tomcat upgrades easier since it won't overwrite configuration files like server.xml. 
And I am goinf to learn how to run two Tomcat instances concurrently on a single Linux server, two separate directories are needed anyway. 
I should keep in mind that it's also possible to run multiple web applications per Tomcat instance. 
I am going to create and configure one web application for each Tomcat instance. 

Setting up Directories and Files

In the following example I setup the first Tomcat instance under the base directory /opt/tomcat-instance/tomcat1.example.com. 
It's a good practice to name the base directory after the site name, in this example tomcat1.example.com. 

Creating a new base directory for a new instance requires the creation and copying of various directories and configuration files. 
Execute the following commands as root:

# mkdir -p /opt/tomcat-instance/tomcat1.example.com
# cd /opt/tomcat-instance/tomcat1.example.com
#
# cp -a /opt/tomcat/apache-tomcat-7.0.30/conf .
# mkdir common logs temp server shared webapps work
#
# chown -R venkat:venkatadmin /opt/tomcat-instance

Most of the remaining steps are executed as the venkat user. So make sure you switch from root to venkat:

# su - -s /bin/sh venkat
$ id
uid=1001(venkat) gid=1001(venkatadmin) groups=1001(venkatadmin)


Next I created an environment file for the new Tomcat instance. 
This will be useful for easily setting the environment variables when starting/stopping the new Tomcat instance:

$ vim /opt/tomcat-instance/tomcat1.env
export JAVA_HOME=/usr/java/jdk1.6.0_10
export PATH=\$JAVA_HOME/bin:\$PATH
export CATALINA_HOME=/opt/tomcat/apache-tomcat-7.0.30
export CATALINA_BASE=/opt/tomcat-instance/tomcat1.example.com


$ cat /opt/tomcat-instance/tomcat1.env
export JAVA_HOME=/usr/java/jdk1.6.0_10
export PATH=$JAVA_HOME/bin:$PATH
export CATALINA_HOME=/opt/tomcat/apache-tomcat-7.0.30
export CATALINA_BASE=/opt/tomcat-instance/tomcat1.example.com


CATALINA_HOME is the base directory of Tomcat that contains all the libraries, scripts etc. for Tomcat. This is the parent directory of the extracted Tomcat tar file.
CATALINA_BASE is the base directory of the new Tomcat instance, which in this example points to /opt/tomcat-instance/tomcat1.example.com. 

Configuring Tomcat Network Ports

Since this is the first Tomcat instance that's being created here, the default port numbers can be left unchanged in $CATALINA_BASE/conf/server.xml (/opt/tomcat-instance/tomcat1.example.com/conf/server.xml):

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

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

Please keep mind, these port numbers will have to be changed for the second Tomcat instance though.

Starting First Tomcat Instance

To start the newly created Tomcat instance, ensure that the environment variables are set for the new instance and execute the startup script:

$ source /opt/tomcat-instance/tomcat1.env
$ $CATALINA_HOME/bin/startup.sh
Using CATALINA_BASE:   /opt/tomcat-instance/tomcat1.example.com
Using CATALINA_HOME:   /opt/tomcat/apache-tomcat-7.0.30
Using CATALINA_TMPDIR: /opt/tomcat-instance/tomcat1.example.com/temp
Using JRE_HOME:       /usr/java/jdk1.6.0_10


If everything has been configured correctly, I should now see an empty white page when opening the URL http://localhost:8080. Note that instead of localhost you should also be able to use the name of your server. 
If you get an error in the browser instead of an empty page, check the log files under $CATALINA_BASE/logs (/opt/tomcat-instance/tomcat1.example.com/logs). 
Note that since CATALINA_BASE has been changed for the new Tomcat instance, the logs are no longer written to /opt/tomcat/apache-tomcat-7.0.30/logs. 

Setting up Web Application Layout

the first Tomcat instance was setup under the base directory $CATALINA_BASE (/opt/tomcat-instance/tomcat1.example.com). 
Now I create a new directory called "WEB1" under $CATALINA_BASE/webapps which will become the root directory for the first web application, that is $CATALINA_BASE/webapps/WEB1. 
In Tomcat web application root directories are created under $CATALINA_BASE/webapps by default.

$ mkdir $CATALINA_BASE/webapps/WEB1

Configuring Web Application

To configure Tomcat to recognize the new web application under $CATALINA_BASE/webapps/WEB1 (/opt/tomcat-instance/tomcat1.example.com/webapps/WEB1), the $CATALINA_BASE/conf/server.xml file needs to be edited. 
This is done by adding a new Context element with the path and docBase attributes. 
Note that Tomcat refers to webapps as "context". So Context here represents the configuration of a web application. 
The path attribute is the application name used within the URL, and the docBase attribute is the absolute path name of the new web application root under $CATALINA_BASE/webapps:

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false">

        <Context docBase="WEB1" path="/web1"/>

In this example you can see that appBase already points to webapps by default, that is $CATALINA_BASE/webapps. 
The newly added path attribute points to the sales directory under $CATALINA_BASE/webapps which is the location for the new application. 
And the docBase attribute is set to web1 which stands for the application name within the URL, i.e. "http://localhost:8080/web1". 
Make sure to add this new Context element inside the Host container element for 'localhost' which is the default host name. 

Home Page for Web Application

To have a starting page for the new web application, you can simply create and add a index.html file under the web application's root directory $CATALINA_BASE/webapps/WEB1 (/opt/tomcat-instance/tomcat1.example.com/webapps/WEB1). 
You could also create your own JSP page here. For testing purposes here is a simple index.html example for the new application:

$ vim $CATALINA_BASE/webapps/WEB1/index.html 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD><META http-equiv=Content-Type content="text/html"></HEAD>
<BODY>
<H3>TOMCAT 1 - WEB1</H3>
</BODY>
</HTML>
$

Restarting First Tomcat Instance

Now check whether the new web application has been configured correctly. To do that, run the following commands to restart the new Tomcat instance:

$ source /opt/tomcat-instance/tomcat1.env
$ $CATALINA_HOME/bin/shutdown.sh
$ $CATALINA_HOME/bin/startup.sh

If everything is right, then you should now see the default home page for the new web application when opening the URL http://localhost:8080/web1. 
Instead of localhost you should also be able to use the name of your server. If you get the error 'java.net.ConnectException: Connection refused' when you shutdown Tomcat, then Tomcat was probably not running. 
If you don't see the home page, check the log files under $CATALINA_BASE/logs. 

Deploying Java Servlet for Web Application in First Tomcat Instance

Setting up Java Servlet Layout

To follow the Java Servlet Specification for the new "WEB1" web application, I created the class directory for the Java class files under the new directory $CATALINA_BASE/webapps/WEB1/WEB-INF. 
The WEB-INF directory is protected from access by browsers, meaning they are unbrowsable and safe from client views. 
The classes directory under WEB-INF is where web components and server-side utility classes should go. To create the WEB-INF and classes directories, run the following command:

$ mkdir -p $CATALINA_BASE/webapps/WEB1/WEB-INF/classes

JAR Files

Most Java servlets also need JAR (Java ARchive) files which should be put under the lib directory. Since it's a good practice to keep the application separate from the Tomcat distribution directory tree, 
I created a new lib directory under $CATALINA_BASE/webapps/WEB1/WEB-INF which is consistent with WAR's hierarchical directory structure.

$ mkdir $CATALINA_BASE/webapps/WEB1/WEB-INF/lib

The Java servlet example below requires the servlet-api.jar JAR file. This JAR is already available in the Tomcat distribution directory tree $CATALINA_HOME/lib. 
You could copy this JAR file to the application's new lib directory $CATALINA_BASE/webapps/WEB1/WEB-INF/lib, but then you would get the following warning in the $CATALINA_BASE/logs/catalina.out log file when you startup Tomcat: 

INFO: validateJarFile(/opt/tomcat-instance/tomcat1.example.com/webapps/WEB1/WEB-INF/lib/servlet-api.jar) - jar not loaded. See Servlet Spec 2.3, section 9.7.2. Offending class: javax/servlet/Servlet.class 

Tomcat shows this warning since it tries now to load the JAR file twice, first from $CATALINA_HOME/lib and then from $CATALINA_BASE/webapps/WEB1/WEB-INF/lib. 
Even though it's not going to be a problem for Tomcat, it's better not to keep JARs in two places. Since the servlet-api.jar JAR file already exists in the Tomcat distribution directory, I did not copy it to the $CATALINA_BASE/webapps/sales/WEB-INF/lib directory. I use this directory for application specific JARs that don't come with the Tomcat distribution. You could also remove the JAR in $CATALINA_HOME/lib but remember that it will reappier the next time you upgrade the Tomcat software. 

Creating a Java Servlet

Since server-side classes are supposed to go to the WEB-INF/classes directory, I created the following class file example under $CATALINA_BASE/webapps/WEB1/WEB-INF/classes (/opt/tomcat-instance/tomcat1.example.com/webapps/WEB1/WEB-INF/classes) 
and saved it as Web1Class.java:

$ cat $CATALINA_BASE/webapps/sales/WEB-INF/classes/Web1Class.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class Web1Class extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    throws IOException, ServletException
    {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Web1 Class Page</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Executing Web1Class ...</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

To compile the new Java servlet, the servlet-api.jar JAR file is needed which can be specified with either the -classpath option or the CLASSPATH environment variable. 
The -classpath option for SDK tools is preferred over the CLASSPATH environment variable since it can be set individually for each application without affecting others. 
In the following example I specify the path of the class directory with the basename '*' (if you are unfamiliar with basename, see 'man basename'). 
This is equivalent to specifying all files with the extensions .jar or .JAR files in the directory and therefore individual JAR files like servlet-api.jar don't need to be specified. 

The following command should now compile the Java servlet without errors:

$ cd $CATALINA_BASE/webapps/WEB1/WEB-INF/classes
$ javac -classpath "$CATALINA_HOME/lib/*" Web1Class.java
$ ls
Web1Class.class  Web1Class.java

Configuring the Java Servlet

To configure servlets and other components for an application, an XML file called web.xml needs to be configured. The format of this file is defined in the Java Servlet Specification. 
In Tomcat, this file exists in two place:
  $CATALINA_BASE/conf/web.xml
  $CATALINA_BASE/webapps/{your-appname}/WEB-INF/web.xml
The first one is the default web.xml file which is the base for all web applications in a Tomcat instance, and the latter one is for the web application where WEB-INF resides for overwriting application specific settings. 

For the newly created Java servlet "Web1Class" I created a new web.xml file under $CATALINA_BASE/webapps/WEB1/WEB-INF:
$ cat $CATALINA_BASE/webapps/WEB1/WEB-INF/web.xml

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

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    version="2.5">

  <servlet>
    <servlet-name>servlet_web1class</servlet-name>
    <servlet-class>Web1Class</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>servlet_web1class</servlet-name>
    <url-pattern>/execute</url-pattern>
  </servlet-mapping>

</web-app>

For each servlet there is a <servlet> element. It identifies the servlet name (<servlet-name>) and the Java class name (<servlet-class>). 
The servlet mapping (<servlet-mapping>) maps a URI to the servlet name (<servlet-name>). In the above example "/execute" in "http://localhost:8080/web1/execute" maps to "servlet_web1class" which points to the "Web1Class" servlet class. 
Note that the order of these elements is important. So when you open the URL "http://localhost:8080/web1/execute", the "Web1Class" Java servlet will be executed. 

In the following example I updated the $CATALINA_BASE/webapps/WEB1/index.html file to provide an entry point to the new Java servlet:

$ cat $CATALINA_BASE/webapps/WEB1/index.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD><META http-equiv=Content-Type content="text/html"></HEAD>
<BODY>
<H3>TOMCAT 1 - WEB1</H3>
<a href="/web1/execute">Execute Web1Class</a>
</BODY>
</HTML>
$

Testing and Executing the Java Servlet

Note that if you run javac with the -classpath option or the CLASSPATH environment variable in the same shell before you startup Tomcat, you will get java.lang.NoClassDefFoundError / java.lang.ClassNotFoundException errors in your browser when you execute a servlet. To avoid this, simply re-login as the venkat user before you startup Tomcat:

# su - -s /bin/sh venkat
$ source /opt/tomcat-instance/tomcat1.env
$ $CATALINA_HOME/bin/shutdown.sh
$ $CATALINA_HOME/bin/startup.sh

After Tomcat restarted, open the URL http://localhost:8080/web1 (or use the server name instead of localhost) and you should see the "Execute Web1Class" link. Clicking on this link should invoke the Java servlet and display "Executing Web1Class..." in your browser. 
If you are presented with an empty page instead, review the above steps and make sure you didn't miss a step. Check also the log files under $CATALINA_BASE/logs.