Apache Tomcat · 9 min read · Oct 23, 2025

Integración simple de Apache 2 Tomcat 5 mod_jk

Integración simple de Apache 2 Tomcat 5 mod_jk

Todo el tutorial se basa en muchos tutoriales, pero hice uno muy simple, sin hosts virtuales. ¡ESTO SOLO HA SIDO PROBADO EN DEBIAN 3.1!!!! Puede que no funcione en otras distribuciones…

La fuente principal de información se puede encontrar aquí:

https://www.howtoforge.com/apache2_tomcat5_mod_jk

Instalando Apache2

Seguí este enlace: https://www.howtoforge.com/perfect_setup_debian_sarge_p5

Ejecuta

apt-get install apache2 apache2-doc   
apt-get install libapache2-mod-php4 libapache2-mod-perl2 php4 php4-cli php4-common php4-curl php4-dev php4-domxml php4-gd php4-imap php4-ldap php4-mcal php4-mhash php4-mysql php4-odbc php4-pear php4-xslt curl libwww-perl imagemagick

Edita /etc/apache2/apache2.conf. Cambia

| DirectoryIndex index.html index.cgi index.pl index.php index.xhtml |

por

| DirectoryIndex index.html index.htm index.shtml index.cgi index.php index.php3 index.pl index.xhtml |

Edita /etc/mime.types y comenta las siguientes líneas:

| #application/x-httpd-php phtml pht php #application/x-httpd-php-source phps #application/x-httpd-php3 php3 #application/x-httpd-php3-preprocessed php3p #application/x-httpd-php4 php4 |

Edita /etc/apache2/mods-enabled/php4.conf y comenta las siguientes líneas:

| # AddType application/x-httpd-php .php .phtml .php3 # AddType application/x-httpd-php-source .phps |

Edita /etc/apache2/ports.conf y agrega Listen 443:

| Listen 80 Listen 443 |

Ahora tenemos que habilitar algunos módulos de Apache (SSL, reescritura y suexec):

a2enmod ssl   
a2enmod rewrite   
a2enmod suexec   
a2enmod include

Reinicia Apache:

/etc/init.d/apache2 restart

Un nuevo usuario www-data será creado automáticamente en el sistema.

Instalando JDK (Java Development Kit)

Para ejecutar Tomcat, necesitarás instalar JDK y establecer la variable de entorno JAVA_HOME para identificar la ubicación del entorno JDK en tu sistema. He elegido usar JDK 5.0.

  1. Puedes descargar JDK 5.0 en http://java.sun.com/j2se/1.5.0/download.jsp.
  2. Haz clic en Descargar JDK 5.0 Update 6 para ir a la página de descarga.
  3. Haz clic en Aceptar para aceptar el acuerdo de licencia.
  4. A continuación, elige el archivo autoextraíble de Linux. Esta es la descarga para el archivo binario autoextraíble en lugar del rpm.
  5. Descarga en tu directorio de descarga preferido. Cambia a ese directorio y hazlo ejecutable ejecutando el siguiente comando:
chmod +x jdk-1_5_0_06-linux-i586.bin

Ahora ejecuta el archivo:

./jdk-1_5_0_06-linux-i586.bin

Ahora deberías tener un nuevo directorio llamado jdk1.5.0_06. Ahora mueve este directorio a la ubicación donde debería ejecutarse. Elegí /usr/lib/.

mv jdk1.5.0_06 /usr/lib

Ahora crea un enlace simbólico llamado jdk a JAVA_HOME con el siguiente comando. Esto te permite cambiar fácilmente entre diferentes jvms si alguna vez lo necesitas.

cd /usr/lib   
ln -s jdk1.5.0_06 jdk

Ahora necesitamos establecer la variable de entorno JAVA_HOME. Agrega lo siguiente al final de /etc/profile justo después de export PATH.

| JAVA_HOME="/usr/lib/jdk" export JAVA_HOME |

/etc/profile se ejecuta al inicio y cuando un usuario inicia sesión en el sistema. Para actualizar el entorno necesitarás cerrar sesión y volver a iniciar sesión en el sistema.

Verifica que JAVA_HOME esté definido correctamente ejecutando el siguiente comando. Esto debería informar la ubicación del SDK de Java que debería ser /usr/lib/jdk.

echo $JAVA_HOME

Instalando Tomcat

En esta sección descargarás e instalarás Apache Tomcat 5.5.16. Para esta configuración en particular, no es necesario construir el paquete desde el código fuente, descargaremos la versión binaria.

  1. Descarga la versión binaria en tu directorio de descarga preferido desde aquí: http://tomcat.apache.org/download-55.cgi. Elige el tar.gz de la sección core para 5.5.16.

  2. Ahora cambia a ese directorio y extrae los archivos usando el siguiente comando:

cd /mydownloads #(asegúrate de cambiar a tu directorio de descarga)   
tar xvzf apache-tomcat-5.5.16.tar.gz

Ahora deberías tener un nuevo directorio llamado apache-tomcat-5.5.16. Ahora mueve este directorio a la ubicación donde debería instalarse. Nuevamente, elegí /usr/lib/. Ten en cuenta que esta ubicación se referirá como CATALINA_HOME en la documentación de Tomcat.

mv apache-tomcat-5.5.16 /usr/lib
  1. A continuación, cambia al directorio /usr/lib/.
cd /usr/lib
  1. Ahora crea un enlace simbólico llamado apache-tomcat a CATALINA_HOME con el siguiente comando.
ln -s apache-tomcat-5.5.16 apache-tomcat

Esto te evitará tener que hacer cambios en los scripts de inicio y apagado cada vez que actualices Tomcat y, si lo deseas, también te permite mantener varias versiones de Tomcat en tu sistema y cambiar fácilmente entre ellas.

Ahora deberías poder iniciar y detener Tomcat desde el directorio CATALINA_HOME/bin. Si estás usando otra shell que no sea la shell bash, necesitarás agregar sh al principio del comando. Ahora deberías poder probar que Tomcat está instalado iniciándolo y abriendo tu navegador e ingresando http://localhost:8080 en tu navegador. El puerto 8080 es el puerto predeterminado para Tomcat y se puede cambiar fácilmente en el archivo /usr/lib/apache-tomcat/conf/server.xml. (Trabajaremos con este archivo más adelante). Si planeas acceder a esta página de forma remota, asegúrate de redirigir el puerto respectivo a la dirección IP de tu servidor dentro de tu enrutador. Ahora deberías ver la página de bienvenida de Tomcat que contiene enlaces a la documentación de Tomcat, así como ejemplos de scripts JSP/Servlet. Verifica que Tomcat esté en funcionamiento ejecutando algunos de los ejemplos que se encuentran en la página de bienvenida.

cd /usr/lib/apache-tomcat/bin   
./startup.sh

Para apagar el servidor, necesitarás ejecutar el siguiente comando. Siéntete libre de probarlo, pero por ahora dejaremos Tomcat en funcionamiento.

./shutdown.sh

Instalando y configurando mod_jk

Para hacer la conexión entre Tomcat y Apache, necesitaremos descargar e instalar el conector mod_jk. Encontrarás que la documentación de Apache recomienda que instales la versión empaquetada de mod_jk si está disponible para tu distribución de Linux en particular. Muchos recursos desactualizados recomiendan instalar el conector mod_jk2, pero he encontrado que ha sido desaprobado y aunque mod_jk fue desarrollado antes que mod_jk2, todavía está completamente soportado y es muy estable.

Mike Millson dio algunas buenas razones para usar mod_jk para conectar Tomcat a Apache para Red Hat aquí: Integrando Tomcat y Apache en Red Hat Linux.

  1. Elegí descargar la fuente actual de los archivos de Apache: http://archive.apache.org/dist/jakarta/tomcat-connectors/jk/source/jk-1.2.15/. Descarga el archivo jakarta-tomcat-connectors-1.2.15-src.tar.gz en tu directorio /usr/src/.

  2. Cambia al directorio /usr/src.

cd /usr/src
  1. A continuación, extrae el contenido para crear el directorio /usr/src/jakarta-tomcat-connectors-1.2.15-src.
tar xvzf jakarta-tomcat-connectors-1.2.15-src.tar.gz
  1. Cambia al directorio /usr/src/jakarta-tomcat-connectors-1.2.15-src/jk/native.
cd jakarta-tomcat-connectors-1.2.15-src/jk/native
  1. Ahora estás listo para crear el archivo de configuración personalizado para tu sistema. Ejecuta lo siguiente:
./buildconf.sh

Esto creará un archivo de configuración en el directorio /usr/src/jakarta-tomcat-connectors-1.2.15-src/jk/native.

  1. Ejecuta el siguiente comando para configurar mod_jk para tu sistema.
    Nota importante: Necesitarás tener apxs2 (herramienta de extensión de APache) instalada y configurada con Apache. Si no la tienes, como fue mi caso, puedes descargar e instalar el paquete apache2-threaded-dev (que reemplazó al antiguo paquete apache-dev) desde www.debian.org. En el momento de escribir esto, el archivo de paquetes de Debian en www.debian.org estaba caído y me refirieron a su sitio temporal hasta que resolvieron sus problemas pdo.debian.net. Encontré el paquete apache2-threaded-dev y pude instalarlo con éxito.
    Asegúrate de incluir la ubicación correcta de apxs2 en tu sistema en la ruta del comando.
./configure --with-apxs=/usr/bin/apxs2
  1. Ahora construye el mod_jk con lo siguiente:
make
  1. Finalmente, si tuviste éxito con los comandos anteriores, copia el mod_jk.so recién creado a tu directorio de módulos de Apache2. Mis módulos estaban ubicados en /usr/lib/apache2/modules.
cd apache-2.0   
cp /usr/src/jakarta-tomcat-connectors-1.2.15-src/jk/native/apache-2.0/mod_jk.so /usr/lib/apache2/modules

Ahora estás listo para pasar a la siguiente etapa, que es comenzar a configurar Apache y Tomcat. Puedes encontrar más información sobre el conector mod_jk en http://tomcat.apache.org/connectors-doc/howto/apache.html.

Configurando Tomcat y Apache

Crea el archivo workers.properties.
Nota importante: Asegúrate de hacer una copia de seguridad de tus archivos de configuración antes de modificarlos.
El archivo workers.properties contiene los detalles sobre cómo cada proceso está vinculado a Tomcat al definir trabajadores que se comunican a través del protocolo ajpv13. Consulta el Workers HowTo para más detalles.

  1. Primero crea el archivo workers.properties en tu directorio raíz de Apache2.
touch /etc/apache2/workers.properties
  1. A continuación, abre el archivo workers.properties y agrega lo siguiente. Puedes encontrar muchos otros ejemplos del archivo workers.properties en internet, pero este es el que creé y parece funcionar bien con las otras partes que ya se han configurado en este tutorial.

| workers.tomcat_home=/usr/lib/apache-tomcat workers.java_home=/usr/lib/jdk ps=/ worker.list=worker1 worker.default.port=8009 worker.default.host=localhost worker.default.type=ajp13 worker.default.lbfactor=1 |

  1. Guarda y cierra el archivo.

  2. Ahora necesitamos abrir el archivo /etc/apache2/apache2.conf y agregar las siguientes líneas al final. (httpd.conf es solo por compatibilidad hacia atrás):

| LoadModule jk_module /usr/lib/apache2/modules/mod_jk.so # Donde encontrar workers.properties JkWorkersFile /etc/apache2/workers.properties # Donde poner los logs de jk JkLogFile /var/log/apache2/mod_jk.log # Establecer el nivel de log de jk [debug/error/info] JkLogLevel info # Seleccionar el formato de log JkLogStampFormat "[%a %b %d %H:%M:%S %Y] " # JkOptions indica enviar SSL KEY SIZE, JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories # JkRequestLogFormat establece el formato de la solicitud JkRequestLogFormat "%w %V %T" # Enviar servlet para el contexto / jsp-examples al trabajador llamado worker1 JkMount /jsp-examples worker1 # Enviar JSPs para el contexto /jsp-examples/* al trabajador llamado worker1 JkMount /jsp-examples/* worker1 |

Guarda y cierra el archivo.

Ahora un último punto de seguridad.

Crearemos un grupo y un usuario tomcat tomcat así:

groupadd tomcat   
useradd -g tomcat tomcat

Luego cambia el usuario y grupo de la ruta de Tomcat:

chown -R tomcat:tomcat /usr/lib/apache-tomcat-5.5.16

Para cambiar la contraseña del usuario tomcat, como root escribe:

passwd tomcat

y sigue las instrucciones.

Luego, para iniciar y detener el servidor Tomcat, deberías usar el usuario tomcat.

su - tomcat

Ahora detén e inicia Tomcat:

cd /usr/lib/apache-tomcat/bin  
./shutdown.sh  
./startup.sh

Y reinicia Apache:

/etc/init.d/apache2 restart

Has terminado.

Pruebas:

En esta prueba, estamos dirigiendo todas las URL que comienzan con “/jsp-examples” a Tomcat.
En una situación del mundo real, podríamos dirigir solo JSPs o servlets al trabajador JK.

Asegúrate de que no haya otro servidor ejecutándose en los puertos predeterminados de Tomcat 8005, 8009 y 8080.
Asegúrate de que no haya otro servidor ejecutándose en el puerto de Apache, que normalmente es 8080 o 80.

Inicia Tomcat primero: Siempre inicia Tomcat primero y luego inicia Apache.
Si tienes que reiniciar Tomcat, recuerda detener Apache primero y reiniciarlo después de que Tomcat se reinicie.
Inicia Apache: Apunta tu navegador a http://localhost y verifica que obtienes la página predeterminada de Apache. Sustituye “localhost” por el nombre de máquina/IP real si es necesario.

Apunta tu navegador a http://localhost:8080 y verifica que obtienes la página predeterminada de Tomcat.

Apunta tu navegador a http://localhost/jsp-examples/ y verifica que obtienes la página de índice de los ejemplos de Tomcat.

Esto será servido por Apache y indicará que has completado tu integración de Apache y Tomcat con éxito.

Referencias y rutas:

Conf de Tomcat:

/usr/lib/apache-tomcat/conf/server.xml

Detener e iniciar Tomcat:

cd /usr/lib/apache-tomcat/bin  
./shutdown.sh  
./startup.sh

Módulos de Apache:

/usr/lib/apache2/modules

Conf de Apache:

/etc/apache2/workers.properties   
/etc/apache2/apache2.conf   
/etc/apache2/httpd.conf

Apache2:

/etc/init.d/apache2 restart   
/etc/init.d/apache2 stop   
/etc/init.d/apache2 start

Para aquellos que necesiten ayuda con este tutorial, por favor publica tus preguntas aquí:

https://www.howtoforge.com/forums/showthread.php?t=3595

O incluso si encuentras algún error en el tutorial, por favor házmelo saber en el foro.

Share: X/Twitter LinkedIn
#Apache Tomcat

Recibe nuevas publicaciones en tu bandeja de entrada.

No spam. Cancela la suscripción en cualquier momento.