Saltar a contenido

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ón POST y 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.62 como 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 tomcat sin acceso interactivo y administrar el ciclo de vida de Tomcat mediante systemd;
  • reconocer las carpetas bin, conf, lib, webapps, logs, work y temp, y distinguir los archivos de configuración de los generados;
  • crear la estructura de una aplicación web Java con una vista HTML, WEB-INF y clases compiladas;
  • compilar dos Servlets con la API jakarta.servlet incluida 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, ss y systemctl.
  • Acceso para editar /etc/hosts si realizas la opción de hosts virtuales o la ampliación con Nginx.
  • Permiso para abrir el puerto 8080/tcp y, si realizas la ampliación de Nginx, el puerto HTTP 80/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

mkdir -p ~/evidencias-tomcat-p2

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:

cat ~/evidencias-tomcat-p2/0.-metodo_elegido.txt

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:

sudo nano /etc/systemd/system/tomcat.service

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:

sudo journalctl -u tomcat --no-pager -n 80
sudo tail -n 80 /opt/tomcat/logs/catalina.out

Si utilizas ufw, abre el puerto de laboratorio:

sudo ufw allow 8080/tcp
sudo ufw status verbose

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:

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

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:

mkdir -p ~/proyectos/saludo-app/WEB-INF/classes
mkdir -p ~/proyectos/saludo-app/WEB-INF/lib

Crea la vista que envía el nombre con una petición HTTP POST:

nano ~/proyectos/saludo-app/index.html

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.

nano ~/proyectos/saludo-app/WEB-INF/classes/SaludoServlet.java

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í:

nano ~/proyectos/saludo-app/WEB-INF/web.xml
<?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:

mkdir -p ~/proyectos/repetidor-app/WEB-INF/classes
mkdir -p ~/proyectos/repetidor-app/WEB-INF/lib

Crea el formulario:

nano ~/proyectos/repetidor-app/index.html

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:

nano ~/proyectos/repetidor-app/WEB-INF/classes/RepetidorServlet.java

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:

nano ~/proyectos/repetidor-app/WEB-INF/web.xml
<?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:

  1. En saludo-app, introduce Pedro y pulsa Aceptar. La respuesta debe mostrar Hola Pedro!! y un enlace Volver.
  2. En saludo-app, repite la petición con el campo vacío usando las herramientas del navegador o una petición manual. El Servlet utiliza Invitado cuando no recibe un nombre válido; el atributo required del formulario evita el caso vacío en el navegador habitual.
  3. En repetidor-app, introduce 4 y pulsa Generar. Deben aparecer cuatro líneas numeradas de ¡Hola mundo!.
  4. 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:

sudo nano /opt/tomcat/conf/server.xml

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:

Cliente :80 → Nginx (servidor web/proxy) → Tomcat :8080 → Servlet → HTML

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:

sudo nano /etc/nginx/sites-available/tomcat-p2
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:

systemd-detect-virt
hostnamectl
ip address
free -h
df -h /

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:

docker stop tomcat-p2
docker start tomcat-p2
docker rm --force tomcat-p2

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 tomcat existe, no utiliza root para ejecutar el servicio y el directorio /opt/tomcat tiene una propiedad coherente.
  • java, javac, jar y servlet-api.jar son compatibles y sus versiones aparecen en la ficha.
  • tomcat aparece como active (running) y está habilitado para iniciar con el sistema.
  • Se ha documentado JAVA_HOME, CATALINA_HOME, CATALINA_BASE y el archivo de servicio.
  • Se han identificado bin, conf, lib, webapps, logs, work y temp, 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-app contiene su HTML, WEB-INF/web.xml, el fuente del Servlet y SaludoServlet.class.
  • repetidor-app contiene su HTML, WEB-INF/web.xml, el fuente del Servlet y RepetidorServlet.class.
  • Los dos WAR se pueden inspeccionar con jar tf y contienen la estructura esperada.
  • Los WAR pertenecen a tomcat y se han detectado en webapps.
  • http://localhost:8080/saludo-app/ y http://localhost:8080/repetidor-app/ responden con el HTML correcto.
  • El formulario de saludo devuelve Hola Pedro!! al enviar Pedro.
  • El repetidor genera cuatro líneas al enviar 4 y rechaza cantidades fuera de 1 a 100.
  • Se ha realizado una prueba POST con curl, 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, journalctl y 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.xml y una forma de repetir o revertir el laboratorio.
  • La carpeta evidencias-tomcat-p2/ contiene las evidencias numeradas del 0 al 15, las copias de los recursos y el README.md.
  • El README.md enlaza 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

  1. 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.
  2. 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.
  3. Jerarquía de Tomcat: relaciona Connector, Service, Engine, Host, Context y Servlet con los archivos o bloques de configuración que has utilizado.
  4. 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 bajo WEB-INF.
  5. WAR y contexto: explica por qué saludo-app.war se publica en /saludo-app/, qué ocurriría con ROOT.war y por qué el nombre no sustituye a la comprobación del contexto efectivo.
  6. HTTP: analiza la salida de curl --include de ambas aplicaciones. Identifica estado, al menos tres cabeceras, método, puerto, contexto y cuerpo. Explica por qué un 200 del formulario no demuestra por sí solo que se haya ejecutado el Servlet correcto.
  7. 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 Host y qué ventajas e inconvenientes tiene cada alternativa.
  8. 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.
  9. 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 para javax.servlet.*.
  10. Seguridad y mantenimiento: explica por qué Tomcat no debe ejecutarse como root, por qué no se deben publicar tomcat-users.xml ni credenciales, qué diferencia hay entre conf y work, y qué copia de recuperación conservarías antes de editar server.xml.
  11. 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.
  12. Evidencias: relaciona cada evidencia del informe con los criterios incluidos en la tabla y marca PASS, FAIL, BLOCKED o N/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:

  1. Cabecera con nombre, fecha, sistema operativo, JDK, versión de Tomcat, método de publicación y tipo de entorno.
  2. Objetivo y alcance de la práctica, indicando qué ampliaciones has realizado.
  3. Diagrama de arquitectura y explicación del recorrido de una petición.
  4. Ficha de requisitos y recursos: permisos, rutas, puertos, firewall, nombres, cliente de prueba y compatibilidad Java/Tomcat.
  5. Comandos de instalación, creación del usuario, servicio systemd, arranque, parada y consulta de registros.
  6. Tabla de rutas de Tomcat y explicación de CATALINA_HOME, CATALINA_BASE, conf, lib, webapps, logs, work y temp.
  7. Los dos index.html, los dos Servlets y los descriptores web.xml, o un enlace a los archivos entregados.
  8. Estructura de cada aplicación, comandos de compilación y versión de servlet-api.jar utilizada.
  9. Contenido relevante de los WAR y evidencia de que Tomcat los ha detectado.
  10. Evidencia del estado systemd, el conector, el puerto y la propiedad de los archivos.
  11. Respuestas curl de los dos contextos, pruebas POST, pruebas funcionales del navegador y prueba negativa.
  12. Configuración y pruebas de hosts virtuales, si realizas el método B.
  13. Configuración, validación, respuestas y logs de Nginx, si realizas el apartado 4.13.
  14. Imagen o contenedor, digest o identificador, recursos, red, puertos y logs, si realizas el apartado 4.14.
  15. Matriz de pruebas con ID, precondiciones, origen, acción, resultado esperado, resultado obtenido, estado (PASS, FAIL, BLOCKED o N/A) y evidencia.
  16. Respuestas a los ejercicios de análisis y relación explícita de cada evidencia con los criterios incluidos en la tabla.
  17. Incidencias encontradas, causa, solución, prueba de cierre y procedimiento de recuperación.
  18. 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:

  • systemctl muestra Tomcat activo y habilitado;
  • ss muestra el conector escuchando en 8080;
  • webapps contiene los WAR y las carpetas desplegadas;
  • catalina.out registra la creación de los contextos sin errores de clases;
  • las dos URL devuelven el HTML correcto;
  • los POST devuelven 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_HOME representa la instalación de binarios y CATALINA_BASE los datos de una instancia. Pueden coincidir en una instalación sencilla.
  • conf contiene configuración; webapps contiene artefactos desplegables; logs, work y temp contienen resultados generados y no deben editarse como si fueran configuración.
  • WEB-INF no se sirve directamente al cliente. classes contiene el bytecode que Tomcat carga y lib puede contener dependencias de la aplicación.
  • El nombre saludo-app.war produce normalmente el contexto /saludo-app/. ROOT.war producirí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 con javax.servlet.* puede producir errores de clases o métodos al desplegar.
  • nginx -t valida 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 404 indica que no se ha encontrado la ruta; un 502 en Nginx suele indicar que no alcanza Tomcat; un 503 indica que algún componente no puede atender la petición. El significado final se confirma con los registros.
  • Un contenedor con estado running no demuestra que el WAR esté operativo: combina el estado del servicio con una petición funcional y los registros.

8. Fuentes y referencias