Práctica 3.2: Múltiples aplicaciones con Tomcat
P2 - Arquitectura y despliegue de múltiples aplicaciones en Apache Tomcat¶
En esta práctica prepararás un servidor de aplicaciones Java con Apache Tomcat 10.1 y publicarás dos aplicaciones web que ejecutan lógica en el servidor:
saludo-app, que recibe un nombre mediante una peticiónPOSTy genera un saludo con un Servlet.repetidor-app, que recibe una cantidad y genera en el servidor varias líneas de «¡Hola mundo!» mediante un bucle Java.
El resultado principal será una instalación de Tomcat ejecutándose con una cuenta de servicio sin privilegios de administración, dos archivos WAR desplegados y pruebas que demuestren que las dos aplicaciones responden de forma independiente. También estudiarás una segunda forma de publicación: los hosts virtuales de Tomcat, que permiten que cada aplicación responda en la raíz de un nombre distinto.
Un servidor web como Nginx entrega principalmente recursos estáticos y puede actuar como proxy inverso. Tomcat, en cambio, proporciona el contenedor de servlets que ejecuta la lógica Java de una aplicación web. En un laboratorio puedes acceder directamente a Tomcat; en una arquitectura más completa puedes colocar Nginx delante y dejar Tomcat en una red interna.
Alcance del laboratorio: la configuración se realiza para aprender y obtener evidencias reproducibles. No la expongas a Internet ni utilices contraseñas, datos personales o claves reales. La instalación de Tomcat 10.1 debe usar una versión concreta compatible con tu JDK; el texto emplea
10.1.62como versión comprobada y te pide comprobar si existe una revisión más reciente de la rama 10.1 antes de descargarla.
1. Objetivos¶
Al terminar la práctica deberías poder:
- diferenciar las responsabilidades de un servidor web, un contenedor de servlets y una plataforma Jakarta EE completa;
- explicar el recorrido cliente → conector HTTP → servicio → motor → host → contexto → Servlet;
- analizar los requisitos de un despliegue Java y registrar el sistema, el JDK, Tomcat, los puertos, los permisos y el tipo de entorno utilizado;
- instalar un JDK compatible y Apache Tomcat 10.1 desde su distribución oficial;
- crear una cuenta de servicio
tomcatsin acceso interactivo y administrar el ciclo de vida de Tomcat mediantesystemd; - reconocer las carpetas
bin,conf,lib,webapps,logs,workytemp, y distinguir los archivos de configuración de los generados; - crear la estructura de una aplicación web Java con una vista HTML,
WEB-INFy clases compiladas; - compilar dos Servlets con la API
jakarta.servletincluida en Tomcat; - empaquetar las aplicaciones como archivos WAR y entender cómo el nombre del WAR determina inicialmente el context path;
- desplegar y probar simultáneamente dos aplicaciones en
/saludo-app/y/repetidor-app/; - configurar hosts virtuales de Tomcat para que cada aplicación use la raíz de un nombre diferente;
- interpretar puertos, cabeceras
Host, códigos HTTP y registros de Tomcat; - comparar la publicación directa con una arquitectura que incorpore Nginx o contenedores;
- documentar comandos, decisiones, incidencias, resultados y evidencias sin exponer información sensible.
2. Relación con RA y criterios de evaluación¶
La práctica se vincula con el RA1: «Implanta arquitecturas web analizando y aplicando criterios de funcionalidad». La tabla recoge los criterios trabajados y las evidencias que debes entregar.
| Código | Descripción literal de la normativa | Evidencia en esta práctica |
|---|---|---|---|
| RA1 | Implanta arquitecturas web analizando y aplicando criterios de funcionalidad. | Arquitectura documentada, aplicaciones desplegadas, pruebas y guía reproducible. |
| RA1.a | Se han analizado aspectos generales de arquitecturas web, sus características, ventajas e inconvenientes. | Apartados 4.1, 4.11 y 7: comparación entre servidor web, Tomcat, context paths y hosts virtuales. |
| RA1.b | Se han descrito los fundamentos y protocolos en los que se basa el funcionamiento de un servidor web. | Apartados 4.1, 4.6, 4.10 y 4.11: HTTP, puerto 8080, peticiones GET y POST, cabecera Host, códigos y curl. |
| RA1.d | Se ha realizado la instalación y configuración básica de servidores de aplicaciones. | Apartados 4.3 a 4.11: JDK, Tomcat, systemd, conector, estructura, WAR y hosts virtuales. |
| RA1.f | Se han realizado pruebas de funcionamiento de los servidores web y de aplicaciones. y de tecnologías de virtualización en la nube y en contenedores. | Apartados 4.10 a 4.12: pruebas HTTP, funcionales, negativas, recuperación y registros de Tomcat. |
| RA1.g | Se ha analizado la estructura y recursos que componen una aplicación web. | Apartados 4.5, 4.7, 4.8 y 4.9: HTML, WEB-INF, classes, .class, Servlet, API compartida y WAR. |
| RA1.h | Se han descrito los requerimientos del proceso de implantación de una aplicación web. | Apartado 3 y ficha de requisitos: JDK, Tomcat, permisos, puertos, nombres, firewall, herramientas y compatibilidad jakarta.*. |
| RA1.i | Se han documentado los procesos de instalación y configuración realizados sobre los servidores web, de aplicaciones. y sobre tecnologías de virtualización en la nube y en contenedores. | Apartados 4.2 a 4.12 e informe final con versiones, comandos, configuraciones, pruebas, incidencias y recuperación. |
3. Requisitos y recursos¶
3.1. Requisitos previos¶
- Una máquina Debian o Ubuntu con una cuenta que pueda utilizar
sudo. - JDK 11 o superior. Tomcat 10.1 y las aplicaciones de este ejercicio deben utilizar una combinación compatible de Java y de la API Servlet.
- Conocimientos básicos de terminal, permisos, rutas, HTML, Java, HTTP y archivos XML.
- Un navegador y las utilidades
curl,wget,tar,jar,javac,ssysystemctl. - Acceso para editar
/etc/hostssi realizas la opción de hosts virtuales o la ampliación con Nginx. - Permiso para abrir el puerto
8080/tcpy, si realizas la ampliación de Nginx, el puerto HTTP80/tcp. - Espacio suficiente para el JDK, Tomcat, dos proyectos, los WAR y las evidencias. No copies secretos ni datos personales al informe.
3.2. Recursos de consulta¶
- Servidor de aplicaciones con Tomcat.
- Pruebas de funcionamiento del despliegue.
- Documentación reproducible de la instalación.
- Arquitecturas web y Comunicación HTTP.
- Documentación oficial de Apache Tomcat 10.1.
- Documentación de la especificación Jakarta Servlet 6.0.
- Una carpeta para evidencias:
Conserva en esta carpeta las salidas de los comandos y las copias de los archivos que se indiquen en los pasos siguientes. No cambies los nombres: la numeración permite comprobar si la entrega está completa.
3.3. Decide el alcance y la forma de publicación¶
La parte principal se realiza mediante context paths derivados de WAR. Así
podrás probar las dos aplicaciones sin modificar todavía server.xml:
| Método | Primera aplicación | Segunda aplicación | Qué se aprende |
|---|---|---|---|
| A. WAR y context path | http://localhost:8080/saludo-app/ |
http://localhost:8080/repetidor-app/ |
Despliegue automático y rutas independientes. |
| B. Hosts virtuales | http://saludo.local:8080/ |
http://repetidor.local:8080/ |
Selección de una aplicación por nombre de host. |
Completa primero el método A. Después realiza el método B en la misma máquina, en una instantánea diferente o como una ampliación documentada. No presentes como una única prueba dos configuraciones que estén compitiendo por la misma carpeta o el mismo contexto.
Registra el método que vas a documentar. Si realizas ambos, conserva una carpeta de evidencias para cada ejecución o indica claramente qué archivos corresponden a cada método:
# Método A: WAR y context path
printf '%b\n' 'A. WAR y context path\thttp://localhost:8080/saludo-app/\thttp://localhost:8080/repetidor-app/\tDespliegue automático por nombre del WAR.' \
> ~/evidencias-tomcat-p2/0.-metodo_elegido.txt
# Método B: hosts virtuales
printf '%b\n' 'B. Hosts virtuales\thttp://saludo.local:8080/\thttp://repetidor.local:8080/\tSelección mediante Host y bloques Host de Tomcat.' \
> ~/evidencias-tomcat-p2/0.-metodo_elegido.txt
Ejecuta solo la línea correspondiente al método de la evidencia que estés recogiendo y comprueba el resultado:
4. Pasos a seguir¶
4.1. Analiza la arquitectura y registra el entorno¶
Antes de cambiar el sistema, dibuja en tu informe un esquema como este y explica qué componente participa en cada tramo:
Cliente (navegador o curl)
│ HTTP :8080
▼
Tomcat
├── Connector HTTP
├── Engine Catalina
├── Host localhost
│ ├── Context /saludo-app → SaludoServlet
│ └── Context /repetidor-app → RepetidorServlet
├── conf/ configuración
├── webapps/ WAR y aplicaciones desplegadas
└── logs/ evidencias de ejecución
Tomcat no entrega simplemente una carpeta cuando recibe una petición. El
conector acepta la comunicación HTTP y la jerarquía Service → Engine →
Host → Context ayuda a seleccionar la aplicación. El Servlet procesa la
petición y genera una respuesta HTML. Esta explicación será una evidencia para
RA1.a y RA1.b.
Registra las características del entorno antes de instalar:
{
echo '=== Fecha ==='
date --iso-8601=seconds
echo '=== Host ==='
hostnamectl
echo '=== Kernel ==='
uname -a
echo '=== Direcciones IP ==='
hostname -I
echo '=== CPU ==='
lscpu | grep -E '^(CPU\(s\)|Model name)'
echo '=== Memoria ==='
free -h
echo '=== Disco raíz ==='
df -h /
} 2>&1 | tee ~/evidencias-tomcat-p2/1.-entorno.txt
Completa esta ficha en el informe:
| Dato | Valor que debes registrar |
|---|---|
| Sistema operativo y versión | |
| Arquitectura de CPU | |
| CPU y memoria asignadas | |
| Espacio libre | |
| Dirección IP del servidor | |
| Cliente desde el que probarás | |
| Método principal: A o B | |
| Puerto de Tomcat | 8080 o el que hayas configurado |
| Fecha y persona que valida | |
| Resultado válido acordado | Dos aplicaciones Java responden y procesan sus formularios. |
4.2. Instala Java y comprueba la compatibilidad¶
Tomcat necesita una máquina virtual Java compatible. En Debian o Ubuntu instala
el JDK, no solo un runtime, porque tendrás que utilizar javac y jar para
compilar y empaquetar los Servlets:
sudo apt update
sudo apt install default-jdk wget curl tar unzip -y
java -version
javac -version
jar --version
readlink -f "$(command -v java)"
Guarda las versiones y la ruta efectiva del JDK:
{
echo '=== Java ==='
java -version
echo '=== Javac ==='
javac -version
echo '=== Jar ==='
jar --version
echo '=== JAVA_HOME efectivo ==='
readlink -f "$(command -v java)"
} 2>&1 | tee ~/evidencias-tomcat-p2/2.-java-y-compatibilidad.txt
Anota las versiones exactas. El texto de partida indica JDK 11 o superior;
comprueba también la matriz de compatibilidad de la versión de Tomcat que
elijas. No mezcles una aplicación compilada para javax.servlet.* con Tomcat
10.1, que utiliza jakarta.servlet.*.
4.3. Crea una cuenta de servicio y descarga Tomcat¶
No ejecutes Tomcat como root. Crea una cuenta de sistema sin shell
interactiva y utiliza /opt/tomcat como directorio de la instalación:
if ! id tomcat >/dev/null 2>&1; then
sudo useradd -m -d /opt/tomcat -U -s /bin/false tomcat
fi
sudo mkdir -p /opt/tomcat
sudo chown tomcat:tomcat /opt/tomcat
Selecciona una revisión concreta de Tomcat 10.1. 10.1.62 es la versión
comprobada al redactar esta práctica; si la página oficial ofrece otra revisión
10.1.x, cambia la variable, comprueba la URL y registra el valor que hayas
utilizado:
TOMCAT_VERSION=10.1.62
cd /tmp
wget "https://dlcdn.apache.org/tomcat/tomcat-10/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.tar.gz"
sudo tar xzvf "apache-tomcat-${TOMCAT_VERSION}.tar.gz" -C /opt/tomcat --strip-components=1
sudo chown -R tomcat:tomcat /opt/tomcat
sudo chmod -R u+x /opt/tomcat/bin
sudo chmod 755 /opt/tomcat /opt/tomcat/{bin,conf,lib,webapps,logs,work,temp}
sudo -u tomcat /opt/tomcat/bin/version.sh
Si la revisión ya no está en el CDN principal, consulta el archivo oficial o elige una revisión publicada y no inventes una URL. En el informe deben aparecer la versión y el origen de la distribución. No descargues instaladores de fuentes no verificadas.
Comprueba las variables que utilizará la instancia:
sudo -u tomcat test -d /opt/tomcat/bin
sudo -u tomcat test -d /opt/tomcat/conf
sudo -u tomcat test -d /opt/tomcat/webapps
sudo ls -ld /opt/tomcat /opt/tomcat/{bin,conf,lib,webapps,logs,work,temp}
Conserva la versión, la cuenta de servicio y las rutas principales:
{
echo '=== Cuenta tomcat ==='
id tomcat
getent passwd tomcat
echo '=== Versión de Tomcat ==='
sudo -u tomcat /opt/tomcat/bin/version.sh
echo '=== Instalación y permisos ==='
sudo ls -ld /opt/tomcat /opt/tomcat/{bin,conf,lib,webapps,logs,work,temp}
echo '=== servlet-api.jar ==='
sudo ls -l /opt/tomcat/lib/servlet-api.jar
} 2>&1 | tee ~/evidencias-tomcat-p2/3.-cuenta-version-y-rutas.txt
4.4. Configura Tomcat como servicio de systemd¶
Crea un servicio para poder arrancar, detener, habilitar y consultar Tomcat de forma uniforme:
Escribe esta definición. JAVA_HOME debe coincidir con la ruta real de tu
instalación; /usr/lib/jvm/default-java es habitual en Debian y Ubuntu, pero
debes comprobarlo si el servicio no arranca:
[Unit]
Description=Apache Tomcat 10 Web Application Container
After=network.target
[Service]
Type=forking
User=tomcat
Group=tomcat
Environment="JAVA_HOME=/usr/lib/jvm/default-java"
Environment="CATALINA_PID=/opt/tomcat/temp/tomcat.pid"
Environment="CATALINA_HOME=/opt/tomcat"
Environment="CATALINA_BASE=/opt/tomcat"
ExecStart=/opt/tomcat/bin/startup.sh
ExecStop=/opt/tomcat/bin/shutdown.sh
RestartSec=10
Restart=always
[Install]
WantedBy=multi-user.target
En nano, guarda con Ctrl + O, pulsa Enter y sal con Ctrl + X.
Recarga la configuración, habilita el servicio y consulta su estado:
sudo systemctl daemon-reload
sudo systemctl enable --now tomcat
sudo systemctl status tomcat --no-pager
sudo systemctl is-enabled tomcat
sudo systemctl cat tomcat | sed -n '1,120p'
La salida esperada contiene active (running) y enabled. Si el servicio no
arranca, no cambies varias cosas a la vez: comprueba primero el JAVA_HOME, la
propiedad de /opt/tomcat, el PID y el registro:
Si utilizas ufw, abre el puerto de laboratorio:
En un entorno que solo se prueba desde el servidor, documenta esa decisión en vez de abrir el puerto a una red que no necesites.
Guarda el estado del servicio y su definición efectiva:
{
echo '=== Servicio habilitado ==='
sudo systemctl is-enabled tomcat
echo '=== Servicio activo ==='
sudo systemctl is-active tomcat
echo '=== Estado ==='
sudo systemctl status tomcat --no-pager
echo '=== Unidad systemd ==='
sudo systemctl cat tomcat | sed -n '1,140p'
} 2>&1 | tee ~/evidencias-tomcat-p2/4.-servicio-systemd.txt
4.5. Reconoce la arquitectura de directorios y archivos¶
Identifica estas rutas de $CATALINA_HOME y $CATALINA_BASE. En esta práctica
ambas apuntan a /opt/tomcat, porque solo se configura una instancia:
| Ruta | Función |
|---|---|
/opt/tomcat/bin/ |
Scripts de arranque, parada y variables de entorno, como startup.sh, shutdown.sh y catalina.sh. |
/opt/tomcat/conf/ |
Archivos maestros de configuración en XML. |
/opt/tomcat/conf/server.xml |
Configura Connector, Service, Engine, Host y otros elementos del servidor. |
/opt/tomcat/conf/web.xml |
Valores web por defecto para las aplicaciones desplegadas. |
/opt/tomcat/conf/tomcat-users.xml |
Usuarios y roles de la base local para herramientas de administración; no lo expongas ni publiques sus contraseñas. |
/opt/tomcat/lib/ |
Bibliotecas comunes del servidor, incluida servlet-api.jar. |
/opt/tomcat/webapps/ |
Directorio habitual de despliegue automático de carpetas y archivos WAR. |
/opt/tomcat/logs/ |
Registros de arranque, aplicaciones y accesos. |
/opt/tomcat/work/ |
Archivos temporales de trabajo, por ejemplo clases generadas a partir de JSP. |
/opt/tomcat/temp/ |
Archivos temporales de la instancia y el PID del servicio. |
Comprueba la estructura sin editar los directorios generados:
sudo ls -la /opt/tomcat
sudo ls -la /opt/tomcat/bin
sudo ls -la /opt/tomcat/conf
sudo ls -la /opt/tomcat/lib/servlet-api.jar
sudo ls -la /opt/tomcat/webapps
sudo ls -la /opt/tomcat/logs
sudo grep -n 'Connector\|Engine\|Host' /opt/tomcat/conf/server.xml | head -n 30
Recoge un inventario manejable de la instalación y de sus bloques principales:
{
echo '=== Directorios principales ==='
sudo find /opt/tomcat -maxdepth 1 -mindepth 1 -printf '%M %u:%g %p\n' | sort
echo '=== Configuración jerárquica ==='
sudo grep -n 'Connector\|Engine\|Host' /opt/tomcat/conf/server.xml | head -n 40
echo '=== Bibliotecas ==='
sudo ls -l /opt/tomcat/lib/servlet-api.jar
echo '=== Aplicaciones desplegadas ==='
sudo find /opt/tomcat/webapps -maxdepth 1 -mindepth 1 -printf '%M %u:%g %p\n' | sort
echo '=== Registros ==='
sudo find /opt/tomcat/logs -maxdepth 1 -type f -printf '%f\n' | sort
} 2>&1 | tee ~/evidencias-tomcat-p2/5.-arquitectura-tomcat.txt
No confundas CATALINA_HOME con CATALINA_BASE: separar ambos valores permite
compartir la instalación de binarios entre varias instancias, mientras que
CATALINA_BASE contiene la configuración, aplicaciones, logs y archivos
temporales de una instancia concreta.
4.6. Comprueba y documenta el conector HTTP¶
El conector HTTP habitual escucha en 8080. Localiza su configuración en
server.xml antes de cambiarla:
sudo grep -n -A6 -B2 '<Connector' /opt/tomcat/conf/server.xml
sudo ss -ltnp | grep ':8080[[:space:]]' || true
curl --include --max-time 10 http://127.0.0.1:8080/
La configuración se parece a esta:
redirectPort="8443" no activa HTTPS. Solo indica el puerto al que podrían
redirigirse algunas peticiones que requieren transporte seguro. Configurar TLS,
certificados y claves pertenece a otra práctica; no pongas certificados reales
en este laboratorio.
Si cambias el puerto, realiza una copia, modifica una propiedad cada vez, reinicia y comprueba el socket y la URL resultante:
sudo cp /opt/tomcat/conf/server.xml ~/evidencias-tomcat-p2/server.xml.inicial
sudo systemctl restart tomcat
sudo systemctl status tomcat --no-pager
sudo ss -ltnp | grep ':8080[[:space:]]' || true
curl --include --max-time 10 http://localhost:8080/
Conserva la configuración del conector, el socket y la respuesta inicial:
{
echo '=== Connector ==='
sudo grep -n -A6 -B2 '<Connector' /opt/tomcat/conf/server.xml
echo '=== Socket 8080 ==='
sudo ss -ltnp | grep ':8080[[:space:]]' || true
echo '=== Respuesta raíz ==='
curl --include --max-time 10 http://localhost:8080/
} 2>&1 | tee ~/evidencias-tomcat-p2/6.-conector-http.txt
4.7. Crea saludo-app¶
Prepara la estructura estándar. WEB-INF no se sirve directamente al cliente;
Tomcat lo utiliza para encontrar el descriptor, las clases y las dependencias:
Crea la vista que envía el nombre con una petición HTTP POST:
Contenido de index.html:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Saludo Backend (Tomcat)</title>
<style>
body { font-family: Arial, sans-serif; margin: 50px; }
input, button { padding: 8px; font-size: 16px; }
</style>
</head>
<body>
<h2>Introduce tu nombre (procesado en servidor)</h2>
<form action="procesar" method="POST">
<label for="nombre">Nombre:</label>
<input id="nombre" type="text" name="nombre" placeholder="Ej. Pedro" required>
<button type="submit">Aceptar</button>
</form>
</body>
</html>
Ahora crea el Servlet. El código usa jakarta.servlet.*, que es el espacio de
nombres de Tomcat 10.1. La validación de nombre vacío es deliberadamente
sencilla para centrar la actividad en el ciclo petición → Servlet → respuesta;
en una aplicación real también deberías escapar correctamente los datos antes
de insertarlos en HTML.
Contenido de SaludoServlet.java:
import java.io.IOException;
import java.io.PrintWriter;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@WebServlet("/procesar")
public class SaludoServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
String nombre = request.getParameter("nombre");
if (nombre == null || nombre.trim().isEmpty()) {
nombre = "Invitado";
}
response.setContentType("text/html;charset=UTF-8");
try (PrintWriter out = response.getWriter()) {
out.println("<!DOCTYPE html><html lang='es'><body style='font-family:Arial; margin:50px;'>");
out.println("<h2>Hola " + nombre.trim() + "!!</h2>");
out.println("<a href='index.html'>Volver</a>");
out.println("</body></html>");
}
}
}
Para dejar constancia de la estructura, añade un descriptor mínimo. El mapeo
del Servlet lo realiza la anotación @WebServlet; por eso no se duplica aquí:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
version="6.0">
<display-name>Saludo Backend</display-name>
</web-app>
Compila enlazando la biblioteca oficial servlet-api.jar de la instalación de
Tomcat. La opción -d garantiza que la clase compilada queda en
WEB-INF/classes:
javac -cp /opt/tomcat/lib/servlet-api.jar \
-d ~/proyectos/saludo-app/WEB-INF/classes \
~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.java
find ~/proyectos/saludo-app -maxdepth 4 -type f -printf '%p\n' | sort
Guarda el inventario, el contenido y las sumas de comprobación del primer proyecto. Las copias permiten revisar la solución sin reconstruirla:
{
echo '=== Inventario ==='
find ~/proyectos/saludo-app -maxdepth 4 -type f -printf '%M %p\n' | sort
echo '=== SHA-256 ==='
sha256sum ~/proyectos/saludo-app/index.html \
~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.java \
~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.class \
~/proyectos/saludo-app/WEB-INF/web.xml
echo '=== index.html ==='
cat ~/proyectos/saludo-app/index.html
echo '=== SaludoServlet.java ==='
cat ~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.java
echo '=== web.xml ==='
cat ~/proyectos/saludo-app/WEB-INF/web.xml
} 2>&1 | tee ~/evidencias-tomcat-p2/7.-saludo-app.txt
cp ~/proyectos/saludo-app/index.html ~/evidencias-tomcat-p2/7.-saludo-app.index.html
cp ~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.java \
~/evidencias-tomcat-p2/7.-saludo-app.SaludoServlet.java
cp ~/proyectos/saludo-app/WEB-INF/web.xml \
~/evidencias-tomcat-p2/7.-saludo-app.web.xml
Debes localizar SaludoServlet.class, SaludoServlet.java, web.xml e
index.html. El .java sirve como fuente de la práctica; el archivo que
Tomcat ejecuta es el .class.
4.8. Crea repetidor-app¶
Prepara la segunda aplicación:
Crea el formulario:
Contenido de index.html:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Repetidor Backend (Tomcat)</title>
<style>
body { font-family: Arial, sans-serif; margin: 50px; }
input, button { padding: 8px; font-size: 16px; }
</style>
</head>
<body>
<h2>Repetidor de Hola Mundo (procesado en servidor)</h2>
<form action="generar" method="POST">
<label for="cantidad">Cantidad:</label>
<input id="cantidad" type="number" name="cantidad" min="1" max="100" placeholder="Ej. 5" required>
<button type="submit">Generar</button>
</form>
</body>
</html>
Crea el Servlet que ejecuta el bucle en el servidor:
Contenido de RepetidorServlet.java:
import java.io.IOException;
import java.io.PrintWriter;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@WebServlet("/generar")
public class RepetidorServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
int cantidad = 0;
try {
cantidad = Integer.parseInt(request.getParameter("cantidad"));
} catch (NumberFormatException e) {
cantidad = 0;
}
response.setContentType("text/html;charset=UTF-8");
try (PrintWriter out = response.getWriter()) {
out.println("<!DOCTYPE html><html lang='es'><body style='font-family:Arial; margin:50px;'>");
if (cantidad <= 0 || cantidad > 100) {
out.println("<p>Introduce un número válido entre 1 y 100.</p>");
} else {
for (int i = 1; i <= cantidad; i++) {
out.println("<div>" + i + ". ¡Hola mundo!</div>");
}
}
out.println("<br><a href='index.html'>Volver</a>");
out.println("</body></html>");
}
}
}
Añade el descriptor mínimo:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
version="6.0">
<display-name>Repetidor Backend</display-name>
</web-app>
Compila y comprueba la clase generada:
javac -cp /opt/tomcat/lib/servlet-api.jar \
-d ~/proyectos/repetidor-app/WEB-INF/classes \
~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.java
find ~/proyectos/repetidor-app -maxdepth 4 -type f -printf '%p\n' | sort
Conserva el inventario, el contenido y las sumas de comprobación del segundo proyecto:
{
echo '=== Inventario ==='
find ~/proyectos/repetidor-app -maxdepth 4 -type f -printf '%M %p\n' | sort
echo '=== SHA-256 ==='
sha256sum ~/proyectos/repetidor-app/index.html \
~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.java \
~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.class \
~/proyectos/repetidor-app/WEB-INF/web.xml
echo '=== index.html ==='
cat ~/proyectos/repetidor-app/index.html
echo '=== RepetidorServlet.java ==='
cat ~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.java
echo '=== web.xml ==='
cat ~/proyectos/repetidor-app/WEB-INF/web.xml
} 2>&1 | tee ~/evidencias-tomcat-p2/8.-repetidor-app.txt
cp ~/proyectos/repetidor-app/index.html ~/evidencias-tomcat-p2/8.-repetidor-app.index.html
cp ~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.java \
~/evidencias-tomcat-p2/8.-repetidor-app.RepetidorServlet.java
cp ~/proyectos/repetidor-app/WEB-INF/web.xml \
~/evidencias-tomcat-p2/8.-repetidor-app.web.xml
4.9. Empaqueta y despliega los dos WAR: método A¶
Un archivo WAR (Web Application Archive) es un ZIP con una estructura
conocida por Tomcat. El nombre del archivo se utiliza inicialmente como
contexto: saludo-app.war se publica en /saludo-app/. Comprueba primero el
contenido antes de copiarlo al servidor:
cd ~/proyectos/saludo-app
jar -cvf ~/proyectos/saludo-app.war *
cd ~/proyectos/repetidor-app
jar -cvf ~/proyectos/repetidor-app.war *
jar tf ~/proyectos/saludo-app.war | sed -n '1,40p'
jar tf ~/proyectos/repetidor-app.war | sed -n '1,40p'
La estructura esperada se parece a esta:
saludo-app.war
├── index.html
└── WEB-INF/
├── web.xml
└── classes/
├── SaludoServlet.class
└── SaludoServlet.java
El fuente .java se incluye porque el comando reproduce el manual de partida.
En un empaquetado de producción conservarías el código fuente fuera del WAR y
publicarías solo los recursos y clases necesarios. En ambos casos, nunca
incluyas secretos en el archivo.
Copia ambos artefactos a webapps/ y asigna la propiedad a la cuenta que
ejecuta Tomcat:
sudo cp ~/proyectos/saludo-app.war /opt/tomcat/webapps/
sudo cp ~/proyectos/repetidor-app.war /opt/tomcat/webapps/
sudo chown tomcat:tomcat /opt/tomcat/webapps/saludo-app.war
sudo chown tomcat:tomcat /opt/tomcat/webapps/repetidor-app.war
sudo ls -l /opt/tomcat/webapps
Con autoDeploy y deployOnStartup activos, Tomcat detectará los WAR y podrá
descomprimirlos. No reinicies automáticamente antes de observar el log: la
evidencia debe mostrar el despliegue. Si no se detectan, reinicia como último
recurso y documenta la razón:
sudo tail -n 100 /opt/tomcat/logs/catalina.out
sudo ls -la /opt/tomcat/webapps/saludo-app
sudo ls -la /opt/tomcat/webapps/repetidor-app
sudo systemctl restart tomcat
sudo tail -n 100 /opt/tomcat/logs/catalina.out
Guarda la estructura de los WAR, su presencia en webapps, las carpetas
desplegadas y las últimas líneas del log:
{
echo '=== saludo-app.war ==='
jar tf ~/proyectos/saludo-app.war | sed -n '1,80p'
echo '=== repetidor-app.war ==='
jar tf ~/proyectos/repetidor-app.war | sed -n '1,80p'
echo '=== webapps ==='
sudo ls -l /opt/tomcat/webapps
echo '=== carpetas desplegadas ==='
sudo find /opt/tomcat/webapps/saludo-app /opt/tomcat/webapps/repetidor-app \
-maxdepth 4 -type f -printf '%M %u:%g %p\n' | sort
echo '=== catalina.out reciente ==='
sudo tail -n 100 /opt/tomcat/logs/catalina.out
} 2>&1 | tee ~/evidencias-tomcat-p2/9.-war-y-despliegue.txt
cp ~/proyectos/saludo-app.war ~/evidencias-tomcat-p2/9.-saludo-app.war
cp ~/proyectos/repetidor-app.war ~/evidencias-tomcat-p2/9.-repetidor-app.war
4.10. Comprueba el método A con HTTP y el navegador¶
Primero comprueba los contextos con curl:
curl --include --max-time 10 http://localhost:8080/saludo-app/
curl --include --max-time 10 http://localhost:8080/repetidor-app/
En cada respuesta busca un estado 200 OK, un Content-Type HTML y el título
correspondiente. Después abre las dos direcciones en el navegador y realiza las
pruebas funcionales:
- En
saludo-app, introducePedroy pulsa Aceptar. La respuesta debe mostrarHola Pedro!!y un enlace Volver. - En
saludo-app, repite la petición con el campo vacío usando las herramientas del navegador o una petición manual. El Servlet utilizaInvitadocuando no recibe un nombre válido; el atributorequireddel formulario evita el caso vacío en el navegador habitual. - En
repetidor-app, introduce4y pulsa Generar. Deben aparecer cuatro líneas numeradas de¡Hola mundo!. - Envía una cantidad
0,101, vacía o no numérica. Debe aparecer el mensaje de validación y no deben generarse líneas fuera del rango.
También puedes probar el método POST desde la terminal. Así compruebas que la
lógica se ejecuta en Tomcat y no en JavaScript del navegador:
curl --include --max-time 10 \
--data-urlencode 'nombre=Pedro' \
http://localhost:8080/saludo-app/procesar
curl --include --max-time 10 \
--data 'cantidad=4' \
http://localhost:8080/repetidor-app/generar
Realiza una prueba negativa con una ruta que no existe y conserva el resultado:
curl --include --max-time 10 http://localhost:8080/saludo-app/no-existe
curl --silent --show-error --include --max-time 10 \
--write-out '\nHTTP=%{http_code} TIME=%{time_total}s\n' \
http://localhost:8080/repetidor-app/no-existe
Conserva en una única evidencia las respuestas del método A:
{
echo '=== GET saludo-app ==='
curl --include --silent --show-error --max-time 10 \
http://localhost:8080/saludo-app/
echo '=== GET repetidor-app ==='
curl --include --silent --show-error --max-time 10 \
http://localhost:8080/repetidor-app/
echo '=== POST saludo-app nombre=Pedro ==='
curl --include --silent --show-error --max-time 10 \
--data-urlencode 'nombre=Pedro' \
http://localhost:8080/saludo-app/procesar
echo '=== POST repetidor-app cantidad=4 ==='
curl --include --silent --show-error --max-time 10 \
--data 'cantidad=4' \
http://localhost:8080/repetidor-app/generar
echo '=== Ruta inexistente ==='
curl --include --silent --show-error --max-time 10 \
http://localhost:8080/saludo-app/no-existe
} 2>&1 | tee ~/evidencias-tomcat-p2/10.-pruebas-metodoA-http.txt
Un 404 controlado indica que la ruta no existe; no demuestra que el resto de
la aplicación esté roto. Registra la URL, el origen, la hora, el resultado
esperado y el resultado obtenido.
Después de probar los formularios en el navegador, completa esta evidencia:
cat > ~/evidencias-tomcat-p2/11.-pruebas-funcionales-metodoA.txt <<'EOF'
# Completa los resultados observados y conserva el estado de cada caso.
## saludo-app — Pedro
Resultado esperado: Hola Pedro!! y enlace Volver.
Resultado observado:
Estado: PASS / FAIL
## saludo-app — nombre vacío
Resultado esperado: Invitado si se envía el POST sin nombre.
Resultado observado:
Estado: PASS / FAIL
## repetidor-app — cantidad 4
Resultado esperado: cuatro líneas numeradas de ¡Hola mundo!.
Resultado observado:
Estado: PASS / FAIL
## repetidor-app — cantidad 0, 101, vacía o no numérica
Resultado esperado: mensaje de validación y ninguna línea fuera de rango.
Resultado observado:
Estado: PASS / FAIL
EOF
nano ~/evidencias-tomcat-p2/11.-pruebas-funcionales-metodoA.txt
4.11. Despliega mediante hosts virtuales de Tomcat: método B¶
Este método permite que cada aplicación responda en la raíz de un nombre
distinto, por ejemplo http://saludo.local:8080/ y
http://repetidor.local:8080/. La selección se realiza mediante la cabecera
HTTP Host y mediante bloques <Host> dentro del <Engine>.
Haz una copia de seguridad y prepara dos appBase independientes:
sudo cp /opt/tomcat/conf/server.xml ~/evidencias-tomcat-p2/server.xml.antes-hosts
sudo mkdir -p /opt/tomcat/webapps-saludo/ROOT
sudo mkdir -p /opt/tomcat/webapps-repetidor/ROOT
sudo cp -r ~/proyectos/saludo-app/* /opt/tomcat/webapps-saludo/ROOT/
sudo cp -r ~/proyectos/repetidor-app/* /opt/tomcat/webapps-repetidor/ROOT/
sudo chown -R tomcat:tomcat /opt/tomcat/webapps-saludo /opt/tomcat/webapps-repetidor
sudo find /opt/tomcat/webapps-saludo /opt/tomcat/webapps-repetidor -maxdepth 3 -type f -printf '%p\n'
Edita el archivo principal:
Dentro del <Engine defaultHost="localhost" name="Catalina"> existente,
añade los hosts. No borres el XML restante ni crees un segundo <Server> o
<Service>:
<Host name="saludo.local"
appBase="webapps-saludo"
unpackWARs="true"
autoDeploy="true" />
<Host name="repetidor.local"
appBase="webapps-repetidor"
unpackWARs="true"
autoDeploy="true" />
El appBase es relativo a CATALINA_BASE, que en esta práctica es
/opt/tomcat. Las carpetas ROOT hacen que cada aplicación se publique en la
raíz del host virtual. Si dejas los WAR del método A en /opt/tomcat/webapps,
seguirán siendo otros contextos del host localhost; documenta si los
conservas o si los retiras para aislar la prueba.
En el equipo cliente registra los nombres. Si el cliente es el propio servidor:
printf '127.0.0.1 saludo.local repetidor.local\n' | sudo tee -a /etc/hosts
getent hosts saludo.local repetidor.local
Si utilizas otro equipo, registra la IP privada del servidor en su fichero
hosts correspondiente. Reinicia Tomcat para cargar server.xml y comprueba
los hosts:
sudo systemctl restart tomcat
sudo systemctl status tomcat --no-pager
sudo tail -n 120 /opt/tomcat/logs/catalina.out
curl --include --max-time 10 http://saludo.local:8080/
curl --include --max-time 10 http://repetidor.local:8080/
Desde el propio servidor también puedes comprobar la selección de Host sin
editar la resolución de nombres:
curl --include --header 'Host: saludo.local' http://127.0.0.1:8080/
curl --include --header 'Host: repetidor.local' http://127.0.0.1:8080/
Conserva la configuración y las pruebas del método B. Si también has entregado
el método A, guarda una copia de la carpeta antes de cambiar el archivo
0.-metodo_elegido.txt:
sudo cp /opt/tomcat/conf/server.xml \
~/evidencias-tomcat-p2/12.-server.xml-metodoB
{
echo '=== Hosts declarados ==='
sudo grep -n -A5 -B2 '<Host' /opt/tomcat/conf/server.xml
echo '=== Resolución local ==='
getent hosts saludo.local repetidor.local || true
echo '=== saludo.local ==='
curl --include --silent --show-error --max-time 10 \
--header 'Host: saludo.local' http://127.0.0.1:8080/
echo '=== repetidor.local ==='
curl --include --silent --show-error --max-time 10 \
--header 'Host: repetidor.local' http://127.0.0.1:8080/
echo '=== Host no registrado ==='
curl --include --silent --show-error --max-time 10 \
--header 'Host: desconocido.local' http://127.0.0.1:8080/
} 2>&1 | tee ~/evidencias-tomcat-p2/13.-pruebas-metodoB-http.txt
En el informe compara ambos métodos: el nombre del WAR selecciona un contexto
dentro de un host, mientras que los bloques <Host> permiten que cada nombre
disponga de su propia aplicación ROOT. Explica también que una cabecera
Host incorrecta puede seleccionar el host predeterminado.
4.12. Observa los registros y administra el ciclo de vida¶
Relaciona las peticiones de las dos aplicaciones con los registros del servicio:
sudo tail -n 40 /opt/tomcat/logs/catalina.out
sudo find /opt/tomcat/logs -maxdepth 1 -type f -printf '%f\n' | sort
sudo journalctl -u tomcat --since '10 minutes ago' --no-pager
sudo systemctl is-active tomcat
sudo systemctl is-enabled tomcat
Si existe un archivo de acceso, identifica al menos una petición de cada contexto. Si el registro de errores no añade líneas durante una prueba correcta, anótalo como resultado revisado; no inventes un error para llenar la evidencia.
Comprueba las operaciones básicas, pero deja el servicio iniciado al terminar:
sudo systemctl restart tomcat
sudo systemctl status tomcat --no-pager
sudo systemctl stop tomcat
sudo systemctl is-active tomcat || true
sudo systemctl start tomcat
sudo systemctl is-active tomcat
Deja el servicio iniciado y conserva los registros y el ciclo de vida:
{
echo '=== Estado activo ==='
sudo systemctl is-active tomcat
echo '=== Estado habilitado ==='
sudo systemctl is-enabled tomcat
echo '=== Estado systemd ==='
sudo systemctl status tomcat --no-pager
echo '=== Journal ==='
sudo journalctl -u tomcat --since '15 minutes ago' --no-pager
echo '=== catalina.out ==='
sudo tail -n 80 /opt/tomcat/logs/catalina.out
echo '=== Ficheros de logs ==='
sudo find /opt/tomcat/logs -maxdepth 1 -type f -printf '%f\n' | sort
} 2>&1 | tee ~/evidencias-tomcat-p2/14.-registros-y-ciclo-vida.txt
Una aplicación no está verificada solo porque systemctl indique active.
Combina el estado del proceso, el socket 8080, la presencia del WAR o del
contexto, la respuesta HTTP, la respuesta funcional y los logs.
4.15. Genera el índice y valida la carpeta de evidencias¶
Cuando hayas terminado los métodos que vas a entregar, genera el README.md.
Los enlaces son relativos y la carpeta puede copiarse al repositorio sin
modificarlos:
cat > ~/evidencias-tomcat-p2/README.md <<'EOF'
# Evidencias — Práctica 2 de Tomcat
Cada archivo contiene una salida, una copia de configuración o una transcripción
de una comprobación. La numeración sigue el orden de la práctica.
| Nº | Evidencia | Contenido |
|---:|---|---|
| 0 | [Método elegido](0.-metodo_elegido.txt) | Método A o B documentado. |
| 1 | [Entorno](1.-entorno.txt) | Sistema, CPU, memoria, disco e IP. |
| 2 | [Java y compatibilidad](2.-java-y-compatibilidad.txt) | Java, `javac`, `jar` y ruta. |
| 3 | [Cuenta, versión y rutas](3.-cuenta-version-y-rutas.txt) | Usuario `tomcat`, versión e instalación. |
| 4 | [Servicio systemd](4.-servicio-systemd.txt) | Estado y unidad de Tomcat. |
| 5 | [Arquitectura Tomcat](5.-arquitectura-tomcat.txt) | Directorios, XML, biblioteca y logs. |
| 6 | [Conector HTTP](6.-conector-http.txt) | `Connector`, socket 8080 y respuesta. |
| 7 | [Saludo app](7.-saludo-app.txt) | Estructura, HTML, Servlet y descriptor. |
| 7c | [HTML de saludo](7.-saludo-app.index.html) | Copia del HTML. |
| 7j | [Servlet de saludo](7.-saludo-app.SaludoServlet.java) | Código fuente. |
| 7x | [Descriptor de saludo](7.-saludo-app.web.xml) | `web.xml`. |
| 8 | [Repetidor app](8.-repetidor-app.txt) | Estructura, HTML, Servlet y descriptor. |
| 8c | [HTML de repetidor](8.-repetidor-app.index.html) | Copia del HTML. |
| 8j | [Servlet repetidor](8.-repetidor-app.RepetidorServlet.java) | Código fuente. |
| 8x | [Descriptor repetidor](8.-repetidor-app.web.xml) | `web.xml`. |
| 9 | [WAR y despliegue](9.-war-y-despliegue.txt) | Contenido, propiedad y despliegue. |
| 9s | [WAR de saludo](9.-saludo-app.war) | Artefacto WAR. |
| 9r | [WAR de repetidor](9.-repetidor-app.war) | Artefacto WAR. |
| 10 | [HTTP método A](10.-pruebas-metodoA-http.txt) | GET, POST y 404. |
| 11 | [Pruebas funcionales A](11.-pruebas-funcionales-metodoA.txt) | Navegador y resultados. |
| 12 | [Configuración método B](12.-server.xml-metodoB) | Copia de `server.xml`. |
| 13 | [HTTP método B](13.-pruebas-metodoB-http.txt) | Host virtual y 404/fallback. |
| 14 | [Registros y ciclo de vida](14.-registros-y-ciclo-vida.txt) | Journal, `catalina.out` y estados. |
| 15 | [Inventario y validación](15.-inventario-y-validacion.txt) | Archivos presentes y enlaces. |
Los informes de solución están fuera de esta carpeta, en el directorio superior
de cada variante.
EOF
Comprueba automáticamente que no falta ningún archivo:
evidencias="$HOME/evidencias-tomcat-p2"
{
echo '=== Inventario ==='
find "$evidencias" -maxdepth 1 -type f -printf '%f\n' | sort -V
echo '=== Archivos requeridos ==='
for archivo in \
0.-metodo_elegido.txt 1.-entorno.txt 2.-java-y-compatibilidad.txt \
3.-cuenta-version-y-rutas.txt 4.-servicio-systemd.txt \
5.-arquitectura-tomcat.txt 6.-conector-http.txt \
7.-saludo-app.txt 7.-saludo-app.index.html \
7.-saludo-app.SaludoServlet.java 7.-saludo-app.web.xml \
8.-repetidor-app.txt 8.-repetidor-app.index.html \
8.-repetidor-app.RepetidorServlet.java 8.-repetidor-app.web.xml \
9.-war-y-despliegue.txt 9.-saludo-app.war 9.-repetidor-app.war \
10.-pruebas-metodoA-http.txt 11.-pruebas-funcionales-metodoA.txt \
12.-server.xml-metodoB 13.-pruebas-metodoB-http.txt \
14.-registros-y-ciclo-vida.txt README.md; do
if test -s "$evidencias/$archivo"; then
echo "OK: $archivo"
else
echo "FALTA O ESTÁ VACÍO: $archivo"
fi
done
echo '=== Enlaces del README ==='
grep -oE '\]\([^)]+' "$evidencias/README.md" | sed 's/^](//' | sort -u
} 2>&1 | tee "$evidencias/15.-inventario-y-validacion.txt"
4.13. Ampliación: Nginx como servidor web y proxy inverso¶
En esta ampliación Nginx será el servidor web de entrada en el puerto 80 y
Tomcat continuará ejecutando los Servlets en 8080. No confundas ambos papeles:
Si el puerto 80 ya está ocupado, trabaja en una instantánea limpia o
documenta qué servicio detienes. Instala y arranca Nginx:
sudo apt update
sudo apt install nginx -y
sudo systemctl enable --now nginx
sudo systemctl status nginx --no-pager
nginx -v
Crea un sitio que publique ambos contextos de Tomcat:
server {
listen 80;
server_name tomcat.local;
location /saludo-app/ {
proxy_pass http://127.0.0.1:8080/saludo-app/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /repetidor-app/ {
proxy_pass http://127.0.0.1:8080/repetidor-app/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Activa el sitio, registra el nombre y valida antes de recargar:
sudo ln -s /etc/nginx/sites-available/tomcat-p2 /etc/nginx/sites-enabled/tomcat-p2
sudo unlink /etc/nginx/sites-enabled/default 2>/dev/null || true
printf '127.0.0.1 tomcat.local\n' | sudo tee -a /etc/hosts
sudo nginx -t
sudo systemctl reload nginx
curl --include --max-time 10 http://tomcat.local/saludo-app/
curl --include --max-time 10 http://tomcat.local/repetidor-app/
Prueba también un POST a través del proxy:
curl --include --max-time 10 \
--data-urlencode 'nombre=Pedro' \
http://tomcat.local/saludo-app/procesar
curl --include --max-time 10 \
--data 'cantidad=4' \
http://tomcat.local/repetidor-app/generar
Guarda la configuración, la validación syntax is ok y los registros de ambos
componentes:
sudo cp /etc/nginx/sites-available/tomcat-p2 ~/evidencias-tomcat-p2/
sudo nginx -T > ~/evidencias-tomcat-p2/nginx-configuracion-efectiva.txt
sudo tail -n 30 /var/log/nginx/access.log
sudo tail -n 30 /var/log/nginx/error.log
La ampliación permite documentar el recorrido completo. El ejemplo presupone que estás
probando el método A. Si utilizas el método B, conserva el nombre virtual que
corresponda en cada bloque location (por ejemplo, saludo.local para
saludo-app y repetidor.local para repetidor-app) en lugar de
tomcat.local. Si ya realizaste la práctica de
Nginx de esta unidad, puedes reutilizar sus evidencias, pero debes indicar en tu
informe qué URL, configuración y pruebas corresponden a este despliegue de
Tomcat.
4.14. Ampliación: ejecución en una máquina virtual o contenedor¶
Elige una de las alternativas siguientes y conserva la evidencia del entorno.
Alternativa A: máquina virtual¶
Repite la parte principal dentro de una máquina virtual Debian o Ubuntu. En tu ficha registra hipervisor, imagen, CPU, memoria, disco, red, instantánea y fecha. Comprueba desde la máquina virtual:
En el informe explica cómo accederías desde el cliente a la IP de la máquina
virtual, qué regla de red permite 8080/tcp y qué instantánea utilizarías para
recuperar el laboratorio.
Alternativa B: Tomcat en Docker¶
Si tienes Docker instalado, utiliza una etiqueta explícita de la imagen oficial
compatible con Tomcat 10.1; no utilices latest. La etiqueta puede variar, por
lo que comprueba la publicada por Docker Hub y anota la que validas:
docker pull tomcat:10.1-jdk17-temurin
docker run --name tomcat-p2 --detach --publish 18080:8080 tomcat:10.1-jdk17-temurin
docker ps
docker image inspect tomcat:10.1-jdk17-temurin --format '{{json .RepoDigests}}'
docker port tomcat-p2
El puerto 18080 del anfitrión se conecta con el 8080 del contenedor. Copia
los dos WAR, observa el despliegue y prueba los contextos:
docker cp ~/proyectos/saludo-app.war tomcat-p2:/usr/local/tomcat/webapps/
docker cp ~/proyectos/repetidor-app.war tomcat-p2:/usr/local/tomcat/webapps/
docker logs --since=2m tomcat-p2
curl --include --max-time 10 http://localhost:18080/saludo-app/
curl --include --max-time 10 http://localhost:18080/repetidor-app/
docker exec tomcat-p2 ls -la /usr/local/tomcat/webapps
Documenta la imagen, el digest, el nombre del contenedor, el mapeo de puertos, los WAR, los logs y las órdenes de parada y limpieza:
No confundas running con una aplicación funcional: en la evidencia deben
aparecer también las respuestas HTTP y los logs de despliegue. Si la etiqueta
no existe en tu plataforma, consulta una etiqueta oficial compatible y registra
la incidencia antes de repetir la prueba.
5. Comprobaciones de finalización¶
Marca una casilla solo cuando tengas la evidencia guardada en el informe o en
~/evidencias-tomcat-p2/:
- El sistema operativo, la IP, la arquitectura, el tipo de entorno, el JDK, la versión de Tomcat y la fecha están registrados.
- Se ha explicado el recorrido cliente → conector → servicio → host → contexto → Servlet con un diagrama propio.
- La cuenta
tomcatexiste, no utilizarootpara ejecutar el servicio y el directorio/opt/tomcattiene una propiedad coherente. -
java,javac,jaryservlet-api.jarson compatibles y sus versiones aparecen en la ficha. -
tomcataparece comoactive (running)y está habilitado para iniciar con el sistema. - Se ha documentado
JAVA_HOME,CATALINA_HOME,CATALINA_BASEy el archivo de servicio. - Se han identificado
bin,conf,lib,webapps,logs,workytemp, y se ha explicado qué rutas no deben editarse manualmente. - El conector HTTP está localizado, el puerto está registrado y el firewall solo permite el acceso necesario.
-
saludo-appcontiene su HTML,WEB-INF/web.xml, el fuente del Servlet ySaludoServlet.class. -
repetidor-appcontiene su HTML,WEB-INF/web.xml, el fuente del Servlet yRepetidorServlet.class. - Los dos WAR se pueden inspeccionar con
jar tfy contienen la estructura esperada. - Los WAR pertenecen a
tomcaty se han detectado enwebapps. -
http://localhost:8080/saludo-app/yhttp://localhost:8080/repetidor-app/responden con el HTML correcto. - El formulario de saludo devuelve
Hola Pedro!!al enviarPedro. - El repetidor genera cuatro líneas al enviar
4y rechaza cantidades fuera de1a100. - Se ha realizado una prueba
POSTconcurl, no solo una comprobación visual del navegador. - Se ha realizado una prueba negativa de una ruta inexistente y se ha
interpretado el
404. - Las peticiones, los despliegues y las incidencias se han contrastado con
catalina.out,journalctly los registros disponibles. - Se ha configurado y probado el método B, o se han conservado las evidencias del método A.
- Si se han realizado las ampliaciones de Nginx o Docker, se han conservado sus configuraciones, pruebas y registros.
- La matriz de pruebas incluye identificador, precondiciones, origen, acción, resultado esperado, resultado obtenido, estado y evidencia.
- El informe no contiene contraseñas, tokens, claves privadas ni datos personales reales.
- La solución incorpora un procedimiento de detención, una copia de
seguridad de
server.xmly una forma de repetir o revertir el laboratorio. - La carpeta
evidencias-tomcat-p2/contiene las evidencias numeradas del0al15, las copias de los recursos y elREADME.md. - El
README.mdenlaza mediante rutas relativas todos los archivos de la carpeta y el informe se conserva fuera de ella, en el mismo directorio.
6. Ejercicios y entregables¶
6.1. Ejercicios de análisis¶
- Arquitectura: crea un diagrama propio y explica qué componente produce cada parte de la respuesta. Diferencia el HTML estático de la respuesta generada por un Servlet.
- Servidor web y servidor de aplicaciones: compara Nginx y Tomcat. Indica quién acepta la petición, quién ejecuta Java, qué componente puede actuar de proxy y por qué no debes afirmar que un HTML estático es lógica de backend.
- Jerarquía de Tomcat: relaciona
Connector,Service,Engine,Host,Contexty Servlet con los archivos o bloques de configuración que has utilizado. - Estructura web: inventaría los recursos de cada aplicación: HTML,
web.xml, fuente Java,.class,servlet-api.jar, WAR, carpeta de despliegue y logs. Indica qué se puede solicitar desde el navegador y qué queda bajoWEB-INF. - WAR y contexto: explica por qué
saludo-app.warse publica en/saludo-app/, qué ocurriría conROOT.wary por qué el nombre no sustituye a la comprobación del contexto efectivo. - HTTP: analiza la salida de
curl --includede ambas aplicaciones. Identifica estado, al menos tres cabeceras, método, puerto, contexto y cuerpo. Explica por qué un200del formulario no demuestra por sí solo que se haya ejecutado el Servlet correcto. - Comparación de publicación: compara el método A y el método B. Explica
qué diferencia un contexto de un host virtual, qué información viaja en
Hosty qué ventajas e inconvenientes tiene cada alternativa. - Diagnóstico: documenta una incidencia reversible: por ejemplo, cambia temporalmente el nombre de un WAR, detén Tomcat o utiliza un host no registrado. Predice el resultado, conserva el primer fallo y explica qué log y qué prueba permiten localizarlo. Restaura el servicio al terminar.
- Compatibilidad: explica por qué
jakarta.servlet.*es necesario con Tomcat 10.1 y qué problema aparecería al trasladar sin cambios una aplicación compilada parajavax.servlet.*. - Seguridad y mantenimiento: explica por qué Tomcat no debe ejecutarse como
root, por qué no se deben publicartomcat-users.xmlni credenciales, qué diferencia hay entreconfywork, y qué copia de recuperación conservarías antes de editarserver.xml. - Entornos aislados: si realizas la ampliación de VM o Docker, compara el puerto interno con el puerto publicado y explica qué evidencia demuestra el funcionamiento del entorno.
- Evidencias: relaciona cada evidencia del informe con los criterios
incluidos en la tabla y marca
PASS,FAIL,BLOCKEDoN/A.
6.2. Entregables¶
Entrega el informe y la carpeta evidencias-tomcat-p2/ en el mismo directorio,
junto con el código y los artefactos necesarios para repetir la práctica. La
carpeta contiene el README.md y las evidencias numeradas; el informe queda
fuera de la carpeta y enlaza sus archivos sin duplicar sus salidas. Debe incluir:
- Cabecera con nombre, fecha, sistema operativo, JDK, versión de Tomcat, método de publicación y tipo de entorno.
- Objetivo y alcance de la práctica, indicando qué ampliaciones has realizado.
- Diagrama de arquitectura y explicación del recorrido de una petición.
- Ficha de requisitos y recursos: permisos, rutas, puertos, firewall, nombres, cliente de prueba y compatibilidad Java/Tomcat.
- Comandos de instalación, creación del usuario, servicio
systemd, arranque, parada y consulta de registros. - Tabla de rutas de Tomcat y explicación de
CATALINA_HOME,CATALINA_BASE,conf,lib,webapps,logs,workytemp. - Los dos
index.html, los dos Servlets y los descriptoresweb.xml, o un enlace a los archivos entregados. - Estructura de cada aplicación, comandos de compilación y versión de
servlet-api.jarutilizada. - Contenido relevante de los WAR y evidencia de que Tomcat los ha detectado.
- Evidencia del estado
systemd, el conector, el puerto y la propiedad de los archivos. - Respuestas
curlde los dos contextos, pruebasPOST, pruebas funcionales del navegador y prueba negativa. - Configuración y pruebas de hosts virtuales, si realizas el método B.
- Configuración, validación, respuestas y logs de Nginx, si realizas el apartado 4.13.
- Imagen o contenedor, digest o identificador, recursos, red, puertos y logs, si realizas el apartado 4.14.
- Matriz de pruebas con ID, precondiciones, origen, acción, resultado esperado,
resultado obtenido, estado (
PASS,FAIL,BLOCKEDoN/A) y evidencia. - Respuestas a los ejercicios de análisis y relación explícita de cada evidencia con los criterios incluidos en la tabla.
- Incidencias encontradas, causa, solución, prueba de cierre y procedimiento de recuperación.
- Fuentes consultadas y fecha de validación de la documentación.
Como conjunto de archivos auxiliares puedes entregar una estructura parecida a esta. Adapta los nombres al contenido real y no incluyas secretos:
entrega-practica002/
├── informe-tomcat-p2.md
└── evidencias-tomcat-p2/
├── README.md
├── 0.-metodo_elegido.txt
├── 1.-entorno.txt
├── 2.-java-y-compatibilidad.txt
├── 3.-cuenta-version-y-rutas.txt
├── 4.-servicio-systemd.txt
├── 5.-arquitectura-tomcat.txt
├── 6.-conector-http.txt
├── 7.-saludo-app.txt
├── 8.-repetidor-app.txt
├── 9.-war-y-despliegue.txt
├── 10.-pruebas-metodoA-http.txt
├── 11.-pruebas-funcionales-metodoA.txt
├── 12.-server.xml-metodoB
├── 13.-pruebas-metodoB-http.txt
├── 14.-registros-y-ciclo-vida.txt
└── 15.-inventario-y-validacion.txt
No es necesario copiar todo /opt/tomcat, catalina.out completo ni la salida
entera de nginx -T: conserva solo los fragmentos necesarios y explica cómo se
obtuvieron. Si entregas un WAR, comprueba antes que no contiene claves,
contraseñas ni ficheros personales.
7. Solución orientativa¶
La siguiente solución permite contrastar el resultado, pero no sustituye a las evidencias de tu propio equipo. Las versiones, direcciones IP, nombres de usuario, horas y líneas de log deben proceder de tu ejecución.
7.1. Estructura esperada de la instalación¶
/opt/tomcat/
├── bin/
├── conf/
│ └── server.xml
├── lib/
│ └── servlet-api.jar
├── logs/
├── temp/
├── webapps/
│ ├── saludo-app.war
│ ├── saludo-app/
│ ├── repetidor-app.war
│ └── repetidor-app/
└── work/
Cada proyecto de construcción debe contener, como mínimo:
saludo-app/
├── index.html
└── WEB-INF/
├── web.xml
└── classes/
├── SaludoServlet.java
└── SaludoServlet.class
repetidor-app/
├── index.html
└── WEB-INF/
├── web.xml
└── classes/
├── RepetidorServlet.java
└── RepetidorServlet.class
7.2. Resultado esperado del despliegue¶
Con el método A, los archivos se encuentran en /opt/tomcat/webapps/ y el
contexto se deriva del nombre del WAR:
| WAR | Contexto esperado | Servlet probado |
|---|---|---|
saludo-app.war |
/saludo-app/ |
POST /saludo-app/procesar |
repetidor-app.war |
/repetidor-app/ |
POST /repetidor-app/generar |
Una instalación válida combina estas evidencias:
systemctlmuestra Tomcat activo y habilitado;ssmuestra el conector escuchando en8080;webappscontiene los WAR y las carpetas desplegadas;catalina.outregistra la creación de los contextos sin errores de clases;- las dos URL devuelven el HTML correcto;
- los
POSTdevuelven el saludo y las cuatro líneas esperadas; - la prueba de una ruta inexistente devuelve
404; - la matriz relaciona cada resultado con su evidencia.
7.3. Resultado esperado de los hosts virtuales¶
Con el método B, las carpetas de aplicación son:
/opt/tomcat/webapps-saludo/ROOT/index.html
/opt/tomcat/webapps-saludo/ROOT/WEB-INF/classes/SaludoServlet.class
/opt/tomcat/webapps-repetidor/ROOT/index.html
/opt/tomcat/webapps-repetidor/ROOT/WEB-INF/classes/RepetidorServlet.class
La URL y la cabecera deben seleccionar aplicaciones distintas:
| Petición | Resultado esperado |
|---|---|
Host: saludo.local + / |
Formulario de saludo |
Host: repetidor.local + / |
Formulario repetidor |
Host: desconocido.local + / |
Host predeterminado o respuesta que debes interpretar según tu configuración |
7.4. Respuestas conceptuales orientativas¶
- Nginx es un servidor web y proxy inverso; Tomcat es un contenedor de servlets. En esta práctica, el código Java se ejecuta en Tomcat, no en el navegador.
CATALINA_HOMErepresenta la instalación de binarios yCATALINA_BASElos datos de una instancia. Pueden coincidir en una instalación sencilla.confcontiene configuración;webappscontiene artefactos desplegables;logs,workytempcontienen resultados generados y no deben editarse como si fueran configuración.WEB-INFno se sirve directamente al cliente.classescontiene el bytecode que Tomcat carga ylibpuede contener dependencias de la aplicación.- El nombre
saludo-app.warproduce normalmente el contexto/saludo-app/.ROOT.warproduciría/, pero el contexto efectivo debe comprobarse en los logs y mediante HTTP. jakarta.servlet.*corresponde al modelo de Tomcat 10.1. Una clase compilada conjavax.servlet.*puede producir errores de clases o métodos al desplegar.nginx -tvalida la sintaxis de Nginx, pero no demuestra que el Servlet responda. Hay que combinar validación,curl, navegador, logs de Nginx y logs de Tomcat.- Un
404indica que no se ha encontrado la ruta; un502en Nginx suele indicar que no alcanza Tomcat; un503indica que algún componente no puede atender la petición. El significado final se confirma con los registros. - Un contenedor con estado
runningno demuestra que el WAR esté operativo: combina el estado del servicio con una petición funcional y los registros.
8. Fuentes y referencias¶
- Normativa del módulo profesional 0614.
- Apache Tomcat 10.1: documentación oficial.
- Apache Tomcat 10.1: guía de instalación y configuración.
- Apache Tomcat 10.1: arquitectura e introducción.
- Apache Tomcat 10.1: despliegue de aplicaciones.
- Apache Tomcat 10.1: configuración del servidor.
- Apache Tomcat 10.1: configuración de hosts virtuales.
- Especificación Jakarta Servlet 6.0.
- Nginx: documentación oficial.
- Documentación de
systemdysystemctl. - Docker Hub: imagen oficial de Tomcat.
- Teoría de servidores de aplicaciones con Tomcat.
- Teoría de pruebas de funcionamiento.
- Teoría de documentación reproducible.