Instalar Apache Tomcat no Linux

Esse artigo é um passo a passo para a instalação do Apache Tomcat 6.0 em um sistema Debian Linux 4.0. Será coberto a configuração de múltiplas instâncias da JVM do Tomcat em um único servidor Linux. As instruções desse guia são aplicáveis a maioria das distribuições Linux.

Introdução

Esse artigo discutirá como instalar o Apache Tomcat 6 em um sistema com o Debian Linux 4.0. Adicionalmente, será mostrado como configurar múltiplas instâncias da JVM do Tomcat em um único servidor Linux. Para cada instância da JVM do Tomcat uma aplicação web e um servlet Java será configurado. Os passos para a instalação do Tomcat desse artigo são aplicáveis a maioria das distribuições Linux.

Note que esse documento não vem com nenhuma garantia de nenhum tipo. Mas todos os esforços foram feitos para fornecer a informação mais acurada possível. Qualquer sugestão de alteração, use o espaço de comentários abaixo.

Instalando o Ambiente de execução do Java (JRE)

Para executar o Tomcat, você precisa do Java Standart Edition (JSE), também conhecido como JDK.

Para a instalação do Tomcat, usaremos a último versão do Java SE SDK disponível nesse momento: Java SE Development Kit (JDK) 6 Update 10 (6u10). Sobre o Java SE 6, Nome da plataforma e números de versão, veja http://java.sun.com/javase/6/webnotes/version-6.html. E para todo o histórico de Java, uma leitura recomendada é o artigo http://en.wikipedia.org/wiki/Java_version_history.

Você pode baixar a última versão do Java JDK em: http://java.sun.com/javase/downloads/index.jsp.

Para o nosso sistema Debian 64-bits selecionamos o binários multiplataforma para Linux da JDK: jdk-6u10-linux-x64.bin. Baixamos o binário no diretório /tmp e instalamos ele com os comandos a seguir (como 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)
#

 

Instalando o software do Tomcat

Baixe a última versão do Tomcat de http://tomcat.apache.org/download-60.cgi. Para o Debian nós iremos baixar o arquivo apache-tomcat-6.0.18.tar.gz que é a última versão disponível nesse momento.

Uma vez que tiver baixado o arquivo tar certifique-se que o checksum MD% coincida com o valor postado no website do Tomcat, em http://www.apache.org/dist/tomcat/tomcat-6/v6.0.18/bin/apache-tomcat-6.0.18.tar.gz.md5:

# md5sum /tmp/apache-tomcat-6.0.18.tar.gz
8354e156f097158f8d7b699078fd39c1  /tmp/apache-tomcat-6.0.18.tar.gz

A instalação do Tomcat a partir de um arquivo tar binário requer a criação manual da conta de usuário Tomcat. Isso não é necessário se você instalar o Tomcat a partir de um pacote RPM em um sistema Linux que suporte RPM.

Por razões de segurança criaremos uma conta de usuário com nenhum shell para rodar o servidor Tomcat:

# groupadd tomcat
# useradd -g tomcat -s /usr/sbin/nologin -m -d /home/tomcat tomcat

(Deve-se observar aqui que outros sistemas Linux terão o nologin dentro de /sbin e não /usr/sbin).

Em seguida extraímos o arquivo tar em /var/lib e alteramos as permissões de todos os arquivos e diretórios para o usuário tomcat:

# cd /var/lib
# tar zxvf /tmp/apache-tomcat-6.0.18.tar.gz
# chown -R tomcat.tomcat /var/lib/apache-tomcat-6.0.18

Para ver a versão do Tomcat que acabamos de instalar, execute:

# /var/lib/apache-tomcat-6.0.18/bin/version.sh
Using CATALINA_BASE:   /var/lib/apache-tomcat-6.0.18
Using CATALINA_HOME:   /var/lib/apache-tomcat-6.0.18
Using CATALINA_TMPDIR: /var/lib/apache-tomcat-6.0.18/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.
#

Iniciando/Parando o Tomcat

Agora tente iniciar o servidor Tomcat para ver se a página inicial do Tomcat será exibida.

Por razões de segurança, não executaremos o servidor Tomcat com o usuário root, mas com o usuário tomcat que foi criado sem nenhuma shell associado. Assim, para executar o Tomcat use o comando su com a opção -p para preservar todas as variáveis de ambiente quando mudar para o usuário tomcat (mais sobre as variáveis de ambiente do Tomcat a seguir). E já que o usuário tomcat não possui um shell, precisa ser especificado a opção -p (Você pode queres usar esse comando su se planeja escrever um script de inicialização e interrompimento).

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

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

Agora verifique se o Tomcat foi iniciado com sucesso abrindo a URL http://localhost:8080 (o número da porta 8080 é a porta padrão usada pelo Tomcat). Note que você deve poder usar também o nome do servidor ao invés de localhost. Uma vez que abrir a URL em seu navegador vocẽ deve ver a página inicial do Tomcat. Se não conseguir ver essa página, cheque os arquivo da pasta $CATALINA_HOME/logs (/var/lib/apache-tomcat-6.0.18/logs).

Antes de passar para os próximos passos, certifique de parar o Tomcat já que nós iremos executar o servidor do Tomcat em um diretório separado por aplicação, o que será visto no próximo capítulo.

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

Alternando para a conta de usuário Tomcat

A maioria dos passos seguintes desse artigo assume que você alternou para a conta de usuário Tomcat. Se você ver um prompt ‘$’, então os passos desse artigo devem ser executados com esse usuário. Se você ver um prompt ‘#’, então os passos devem ser executados como usuário root.

Já que por razões de segurança o usuário tomcat não possui um shell, precisamos especificar um com a opção -s quando formos alterna de root para tomcat:

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

Note que usuários não-root não podem alterna para a conta tomcat.

Configurando a primeira instãncia da JVM do Tomcat

É recomendável não armazenar o arquivos das aplicações web no mesmo diretório da distribuição do Tomcat. Por exemplo, ter um diretório separado torna as atualizações do Tomcat mais simples já que não precisaremos sobrescrever os arquivos de configuração, como o server.xml. E como esse tutorial mostra como executar duas instâncias do Tomcat ao mesmo tempo em um servidor Linux, dois diretórios separados são necessários de qualquer forma. Devemos observar que também é possível executar múltiplas aplicações web por instância da JVM. Esse HOWTO mostra a criação e configuração de uma aplicação web por cada instância do Tomcat.

Configurando diretórios e arquivos

No exemplo abaixo é configurado a primeira instância da JVM dentro do diretório /opt/tomcat-instance/sales.example.com. É uma boa prática dar um nome ao diretório base igual o nome do site, como no exemplo sales.example.com.

A criação de um novo diretório base para uma nova instância requer a criação de vários diretórios e arquivos de configuração. Execute os seguintes comandos como root:

# mkdir -p /opt/tomcat-instance/sales.example.com
# cd /opt/tomcat-instance/sales.example.com
#
# cp -a /var/lib/apache-tomcat-6.0.18/conf .
# mkdir common logs temp server shared webapps work
#
# chown -R tomcat.tomcat /opt/tomcat-instance

Muitos dos passos restantes são executados pelo usuário tomcat. Assim certifique-se de alternar de root para ele:

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

Em seguida cria um arquivo de ambiente para a nova instância. Isso será útil para facilmente configurar variáveis de ambiente que for iniciar/interromper a nova instância do Tomcat:

$ cat > /opt/tomcat-instance/sales.env << EOF
export JAVA_HOME=/usr/java/jdk1.6.0_10
export PATH=\$JAVA_HOME/bin:\$PATH
export CATALINA_HOME=/var/lib/apache-tomcat-6.0.18
export CATALINA_BASE=/opt/tomcat-instance/sales.example.com
EOF
$
$ cat /opt/tomcat-instance/sales.env
export JAVA_HOME=/usr/java/jdk1.6.0_10
export PATH=$JAVA_HOME/bin:$PATH
export CATALINA_HOME=/var/lib/apache-tomcat-6.0.18
export CATALINA_BASE=/opt/tomcat-instance/sales.example.com
$

O diretório CATALINA_HOME é o diretório base do Tomcat que contém todas as bibliotecas, scripts, etc que o Tomcat usa. Este é o diretório raiz do arquivo tar que extraímos. O diretório CATALINA_BASE é o diretório base da nova instância do Tomcat, que em nosso exemplo, aponta para /opt/tomcat-instance/sales.example.com.

Configurando as portas de rede do Tomcat

Já que essa é a primeira instância do Tomcat que foi criada, os números de porta padrão podem ser deixados inalterados em $CATALINA_BASE/conf/server.xml (/opt/tomcat-instance/sales.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" />

Porém, esses números terão que ser alterados quando uma segunda instância foi criada.

Iniciando a primeira instância do Tomcat

Para iniciar a instância recém-criada do Tomcat, garanta que as variáveis de ambiente foram configuradas para ela e execute o script de inicialização:

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

Se tudo foi configurado corretamente, você deve agora ver uma página em branco quando abrir a URL http://localhost:8080. Note que ao invés de localhost você deve ser capaz de usar o nome de seu servidor.

Se obter uma mesnagem de erro no navegador ao invés da página em branco, cheque os arquivos de log em $CATALINA_BASE/logs (/opt/tomcat-instance/sales.example.com/logs). Note que como CATALINA_BASE foi alterada para a nova instância, os logs não são mais gravados em /var/lib/apache-tomcat-6.0.18/logs.

Direcionando Conexões para Portas HTTP 80 para a Porta Tomcat 8080

Por padrão, o Tomcat escuta na porta 8080. Para que o próprio Tomcat escute em um porta HTTP 80, teremos que executa-lo como root já que apenas o root pode escutar em portas abaixo de 1024 no Linux. Mas por razões de segurança, isso não é recomendado. A solução preferível é retransmitir conexões da porta 80 para a 8080 usando o Netfiler que vem com o Linux. Uma solução alternativa seria usar um empacotador como o jsvc do Jakarta Commons Daemon project. mas essa solução irá requerer a instalação e manutenção de outra peça de software em seu sistema, coisa que não queremos.

O pacote Netfilter que já vem com o Linux é transparente para o Tomcat. Os passos seguintes mostram como direcionar conexões da porta 80 para a 8080 usando o comando iptables do pacote Netfilter. Observe que esses passos precisam ser executados como root:

# iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080
# iptables -t nat -I OUTPUT -p tcp --dport 80 -j REDIRECT --to-ports 8080

A primeira regra direciona requisições de entrada na porta 80 gerada de outros computadores, e a segunda regra direciona as mesmas requisições geradas a partir de um computador local da rede onde o Tomcat esteja sendo executado.

Para checar as regras que acabamos de configurar, execute:

# iptables -t nat -L
Chain PREROUTING (policy ACCEPT)
target     prot opt source               destination
REDIRECT   tcp  --  anywhere             anywhere            tcp dpt:www redir ports 8080 

Chain POSTROUTING (policy ACCEPT)
target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination
REDIRECT   tcp  --  anywhere             anywhere            tcp dpt:www redir ports 8080
#

Para remover as regras NAT que acabamos de criar, só execute o comando iptables -t nat -F, que as regras serão apagadas. Observe que isso também apagará qualquer outra regra que possa ter sido configurada em seu sistema. Para obter mais informações sobre o iptabels, veja netfilter/iptables documentation.

Para garantir que as regras sejam permanentes, você pode usar a opção abaixo. Primeiro salve as regras recém-criadas em um arquivo:

# iptables-save > /etc/iptables.conf

Depois edite o aquivo /etc/network/interfaces e adicione a linha destacada em azul na interface de rede pública. por exemplo:

iface eth0 inet static
        address 192.168.1.23
        netmask 255.255.255.0
        network 192.168.1.0
        broadcast 192.168.1.255
        gateway 192.168.1.1
        pre-up iptables-restore < /etc/iptables.conf

A configuração pre-up nesse exemplo ativa as regras do iptables em nossa sistema antes que a interface eth0 seja ativada. Assim as regras podem ser vistas com o comando iptables -t nat -L após cada reboot. Observe que por razões de segurança é importante que as regras do firewall sejam estabelecidas antes que a interface de rede seja ativada. Mesmo que isso não seja um problema para o Tomcat, como boa prática, as regras do iptabels devem sempre ser estabelecidas antes da interface de rede.

Deve-se notar aqui que existe um parâmetro de configuração do Tomcat que você pode ou não querer alterar, que é o proxyPort do arquivo server.xml. Já que o Tomcat ainda recebe requisições na porta 8080 já que elas são redirecionadas pelo Linux da porta 80, o Tomcat pode exibir a porta 8080 na URL dependendo do contexto da aplicação. Dessa forma, se você quiser alterar a porta para 80, o parâmetro proxyPort deve ser adicionado ao arquivo $CATALINA_BASE/conf/server.xml (/opt/tomcat-instance/sales.example.com/conf/server.xml). para a porta 8080:

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

Depois disso você precisa reiniciar o Tomcat para efetivar essa mudança.

Conexão a primeira instância do Tomcat usando a porta HTTP padrão

Se o iptables tiver sido configurado corretamente, você agora deve poder acessar a IRL http://localhost e ver um página em branco. Você também poderia usar a URL http://localhost:80 (a porta 80 é a porta padrão usada pelos navegadores) ou o nome do servidor. Se for exibida uma mensagem de erro ao invés de uma página em branco, cheque a configuração do iptables e os arquivo de log no diretório $CATALINA_BASE/logs (/opt/tomcat-instance/sales.example.com/logs). Note que como CATALINA_BASE foi alterado para uma nova instância do Tomcat, os logs não estarão mais em /var/lib/apache-tomcat-6.0.18/logs.

Configurando uma aplicação Web para a Primeira Intância da JVM do Tomcat

Você pode configurar múltiplas aplicações web para cada instância da JVM do Tomcat. Nesse guia iremos configurar uma aplicação web para cada instância. Em primeiro lugar certifique-se de alternar para a conta de usuário tomcat e ajustar as variáveis de ambiente:

# su - -s /bin/sh tomcat
$ source /opt/tomcat-instance/sales.env

Configurando um layout para a aplicação web

No capitulo anterior a primeira instância  da JVm do Tomcat foi configurada no diretório base $CATALINA_BASE (/opt/tomcat-instance/sales.example.com). No exemplo a seguir, criamos um diretório chamado “sales” dentro de$CATALINA_BASE/webapps que será o diretório raiz para nossa primeira aplicação web. No Tomcat, os diretórios raizes para as aplicações web são criados dentro de $CATALINA_BASE/webapps por padrão.

$ mkdir $CATALINA_BASE/webapps/sales

Configurando a aplicação web

Para configurar o Tomcat de modo que ele reconheça a nova aplicação instalada em $CATALINA_BASE/webapps/sales (/opt/tomcat-instance/sales.example.com/webapps/sales), o arquivo $CATALINA_BASE/conf/server.xml precisa ser editado. Isso é feito pela adição de um novo elemento Context com os atributos path e docBase. Note que o Tomcat refere-se as aplicações web como “context”. Dessa forma, Context, representa aqui a configuração de um aplicação web. O atributo path é o nomeda aplicação usando dentro da URL, e  docBase é o caminho absoluto da nova aplicação web:

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

        <Context docBase="sales" path="/mysales"/>

Nesse exemplo, você pode ver que appBase já aponta para webapps por padrão. O atributo path recém adicionado aponta para o diretório sales dentro de $CATALINA_BASE/webapps que é a localização da nova aplicação. E o atributo docBase é ajustado para mysales  que guarda o nome da aplicação na URL, isto é, “http://localhost/mysales” or “http://localhost:8080/mysales“. Certifique-se de adicionar esse novo elemento Context dentro do elemento Host para ‘localhost‘ que é o nome do host padrão.

Página inicial para a aplicação web

Para ter uma página de início para sua nova aplicação web, você pode simplesmente criar um arquivo index.html dentro do diretório raiz da aplicação -> $CATALINA_BASE/webapps/sales (/opt/tomcat-instance/sales.example.com/webapps/sales). Você pode também  criar a sua própria página JSP. Como teste, abaixo segue um exemplo de página index.html para a nova aplicação:

$ cat > $CATALINA_BASE/webapps/sales/index.html << EOF
<!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>Apache Tomcat Sales Home Page</H3>
</BODY>
</HTML>
EOF
$

Reiniciando a primeira insância do Tomcat

Agora cheque se a nova aplicação foi configurada corretamente. Para fazer isso, execute os comandos abaixo para reiniciar a nova instância da JVM do Tomcat:

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

Se tudo estiver configurado corretamente, você deve ver agora a página inicial padrão da aplicação quando abrir a URL http://localhost/mysales or http://localhost/mysales:8080. Ao invés de localhost, você pode também usar o nome de seu servidor. Se aparecer uma mensagem de erro ‘java.net.ConnectException: Connection refused‘ quando desligar o Tomcat, então ele provavelmente não estava sendo executado. Se não conseguir acessar a página de inicio, cheque os arquivos de log em $CATALINA_BASE/logs.

Carregando um Servlet Java para a Aplicação Web na Primeira instância da JVm do Tomcat

 

Configurando o layout do servlet Java

Para seguir as  Especificação de Servlet do Java para a nova aplicação “sales”, criaremos um diretório class para guardar os arquivos de classe dentro do diretório $CATALINA_BASE/webapps/sales/WEB-INF veja Packaging Web Components. O diretório WEB-INF é protegido do acesso dos navegadores, o que significa que  eles não são navegáveis e expostos as visitas dos clientes. O diretório classes em WEB0INF é onde os componentes web e classes utilitárias do lado do servidor devem ficar. Para criar os diretórios WEB-INF e classes, execute o comando abaixo:

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

Arquivos JAR

Muitas servlets Java precisam que os arquivos JAR  sejam colocados dentro do diretório lib. Como é uma boa prática manter a aplicação separada da distribuição Tomcat, criaremos um novo diretório lib dentro de $CATALINA_BASE/webapps/sales/WEB-INF, que é consistente com a estrutura de diretórios de um WAR.

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

O servlet exemplo a seguir requer o arquivo servlet-api.jar. Esse JAR já está disponível no diretório da distribuição do Tomcat em $CATALINA_HOME/lib. Você pode copiar esse arquivo JAR para o novo diretório lib da aplicação ($CATALINA_BASE/webapps/sales/WEB-INF/lib), mas com isso receberá o seguinte aviso quando iniciar o Tomcat:

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

O Tomcat mostra esse aviso pois ele irá ter que carregar o arquivo JAR duas vezes, primeiro de $CATALINA_HOME/lib e depois de $CATALINA_BASE/webapps/sales/WEB-INF/lib. mesmo que isso não seja um problema para o Tomcat, é melhor não manter os JAR em dois lugares. Já que o arquivo servlet-api.jar já existe no diretório da distribuição do Tomcat, não copiaremos ele para o diretório $CATALINA_BASE/webapps/sales/WEB-INF/lib. Usaremos esse diretório para especificar JARs específicos da aplicação que não acompanham o Tomcat. Você também poderia remover  o JAR de $CATALINA_HOME/lib mas lembre-se de que esse arquivo irá reaparecer quando o Tomcat for atualizado.

Criando um servlet Java

Como classes do lado do servidor devem ficar no diretório WEB-INF/classes, criaremos o arquivo de classe seguinte em $CATALINA_BASE/webapps/sales/WEB-INF/classes (/opt/tomcat-instance/sales.example.com/webapps/sales/WEB-INF/classes) e salvaremos ele como Sales.java:

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

public class Sales 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>Sales Page</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Executing Sales ...</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

Para compilar o novo servlet Java, o arquivo servlet-api.jar é necessário, o que pode ser especificado ou com a opção -classpath ou com a variável de ambiente CLASSPATH. A opção -classpath do SDk é preferível em relação a variável de ambiente CLASSPATH pois pode ser ajustada para cada aplicação sem afetar as outras. No exemplo abaixo especificamos o caminho do diretório class com o nome-base ‘*’ (se não estiver familiarizado com nomes-base, veja ‘man basename’). Isso é equivalente a especificar todos os arquivos com extensão JAR ou arquivos JAR no diretório e assim JARs individuais como servlet-api.jar não precisam ser especificados.

O comando abaixo deve compilar o servlet Java sem erros:

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

Configurando um servlet Java

Para configurar os servlets e os outros componentes de uma aplicação, um arquivo XML chamado web.xml precisa ser configurado. O formato desse arquivo é definido na Especificação de Servlet do Java. No Tomcat, esse arquivo pode existir em dois locais:

  $CATALINA_BASE/conf/web.xml
  $CATALINA_BASE/webapps/{your-appname}/WEB-INF/web.xml

O primeiro é o arquivo web.xml padrão que será a base para toda a aplicação em um instância da JVM do Tomcat, e o seguinte é o específico da aplicação.

Para o recém-criado servlet “Sales”, criaremos um novo arquivo web.xml em $CATALINA_BASE/webapps/sales/WEB-INF:

$ cat $CATALINA_BASE/webapps/sales/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_sales</servlet-name>
    <servlet-class>Sales</servlet-class>
  </servlet>

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

</web-app>

Para cada servlet existe um elemento <servlet>. Ele identifica o nome do servlet (<servlet-name>) e o nome da classe Java (<servlet-class>). O mapeamento do servlet (<servlet-mapping>) mapeia uma URI para o nome do servlet (<servlet-name>). No exemplo acima “/execute” em “http://localhost:8080/mysales/execute” é mapeado para “servlet_sales” que aponta para a classe “Sales”. Note que a ordem desses elementos é importante. Assim quando você abrir a URL “http://localhost:8080/mysales/execute“, o servlet “Sales” será executado.

No exemplo a seguir atualizamos o arquivo $CATALINA_BASE/webapps/sales/index.html para fornecer um ponto de entrada para o novo servlet:

$ cat $CATALINA_BASE/webapps/sales/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>Apache Tomcat Sales Home Page</H3>
<a href="/mysales/execute">Execute Sales</a>
</BODY>
</HTML>
$

Testando e executando o servlet Java

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 tomcat user before you startup Tomcat:

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

Depois que o Tomcat é reiniciado, abra a URL http://localhost/mysales (ou use o nome do servidor no lugar de localhost) e você deve ver o link “Execute Sales”. Clicando nesse link o servlet será invocado e exibirá a mensagem “Executing sales” em seu navegador. Se for  exibida uma página em branco, repasse os passos acima e certifique-se de não ter pulado nenhum. Cheque também os arquivos de log em $CATALINA_BASE/logs.

Configurando uma segunda instância da JVM do Tomcat

Se você passou por todos os passos anteriores desse tutorial, os próximos passos devem ser muitos fáceis de seguir e entender sem muita explicação. Assim, será mostrado somente os passos para configurar uma segunda instância da JVM do Tomcat e uma aplicação chamada “Order”.

Passos para a criação da segunda instância da JVM do Tomcat

Faça login com root e execute os seguintes comandos para configurar uma segunda instância da JVM do Tomcat:

# mkdir -p /opt/tomcat-instance/order.example.com
# cd /opt/tomcat-instance/order.example.com
#
# cp -a /var/lib/apache-tomcat-6.0.18/conf .
# mkdir common logs temp server shared webapps work
#
# chown -R tomcat.tomcat /opt/tomcat-instance/order.example.com
#
# su - -s /bin/sh tomcat
$ cat > /opt/tomcat-instance/order.env << EOF
export JAVA_HOME=/usr/java/jdk1.6.0_10
export PATH=\$JAVA_HOME/bin:\$PATH
export CATALINA_HOME=/var/lib/apache-tomcat-6.0.18
export CATALINA_BASE=/opt/tomcat-instance/order.example.com
EOF
$
$ source /opt/tomcat-instance/order.env
$

Para essa segunda instância, o número padrão da porta precisa ser alterado em $CATALINA_BASE/conf/server.xml (/opt/tomcat-instance/order.example.com/conf/server.xml). No exemplo a seguir, esse número foi incrementado em 1:

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

    <Connector port="8081" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8444" />

    <Connector port="8010" protocol="AJP/1.3" redirectPort="8444" />

Crie um novo diretório raiz para a aplicação:

$ mkdir $CATALINA_BASE/webapps/order

Para configurar a nova aplicação web, edite $CATALINA_BASE/conf/server.xml (/opt/tomcat-instance/order.example.com/conf/server.xml) e adicione a entrada em azul abaixo:

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

        <Context docBase="order" path="/myorder"/>

Crie uma nova página de início para a aplicação “Order” e inclua um link para o servlet que será configurado a seguir:

$ cat > $CATALINA_BASE/webapps/order/index.html << EOF
<!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>Apache Tomcat Order Home Page</H3>
<a href="/myorder/execute">Execute Order</a>
</BODY>
</HTML>
EOF
$

Agora crie e configure um novo servlet Java:

$ mkdir -p $CATALINA_BASE/webapps/order/WEB-INF/classes
$ mkdir $CATALINA_BASE/webapps/order/WEB-INF/lib
$ cat $CATALINA_BASE/webapps/order/WEB-INF/classes/Order.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class Order 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>Order Page</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Executing Order ...</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

Compile o novo servlet:

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

Configure-o:

$ cat $CATALINA_BASE/webapps/order/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_order</servlet-name>
    <servlet-class>Order</servlet-class>
  </servlet>

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

</web-app>

Agora certifique-se de refazer o login com a conta de usuário tomcat e inicar a segunda instância da JVM do Tomcat:

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

Depois que a segunda instância for iniciado, acesse a URLhttp://localhost:8081/myorder (pode ser usada o nome do servidor no lugar de localhost) e você deve ver o link “Execute order”. Clicando nesse link o servlet será invocado e exibirá a mensagem “Executing order” em seu navegador. Se for  exibida uma página em branco, repasse os passos acima e certifique-se de não ter pulado nenhum. Cheque também os arquivos de log em $CATALINA_BASE/logs.

Traduzido de http://www.puschitz.com/InstallingTomcat.html