Saltar a contenido

Práctica 3.1: Múltiples sitios con Nginx

P1 - Instalación, arquitectura y despliegue de múltiples sitios en Nginx

En esta práctica prepararás un servidor GNU/Linux basado en Debian o Ubuntu, instalarás Nginx y publicarás simultáneamente dos aplicaciones web estáticas que incluyen interacción en el navegador:

  • saludo-app, que recoge un nombre y muestra un saludo.
  • repetidor-app, que genera tantas líneas de «¡Hola mundo!» como se indique.

Aprenderás qué ocurre desde que una persona escribe una URL hasta que Nginx entrega el archivo index.html, cómo se organizan los sitios virtuales y cómo se comprueba que el despliegue funciona. La práctica se realiza en un entorno de aula; no pretende convertir esta configuración mínima en un servidor de producción.

1. Objetivos

Al terminar la práctica deberías poder:

  • explicar la arquitectura cliente → Nginx → raíz del sitio → recursos web;
  • instalar, iniciar, habilitar y consultar el servicio Nginx;
  • localizar la configuración global, los sitios disponibles y habilitados, el contenido web y los registros;
  • crear una aplicación web estática con HTML, CSS y JavaScript en una raíz pública;
  • configurar dos sitios virtuales y diferenciarlos por puerto o por nombre de dominio;
  • validar la sintaxis, recargar la configuración y comprobar respuestas HTTP;
  • interpretar códigos de estado, registros de acceso y registros de error;
  • documentar el entorno, las decisiones, los comandos, las incidencias y las evidencias de forma reproducible.

2. Relación con RA y criterios de evaluación

La práctica desarrolla el RA1: «Implanta arquitecturas web analizando y aplicando criterios de funcionalidad». La tabla recoge los criterios de evaluación 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, dos sitios publicados, pruebas y guía reproducible.
RA1.a Se han analizado aspectos generales de arquitecturas web, sus características, ventajas e inconvenientes. Apartados 4.1 y 6, con el diagrama cliente–Nginx–sitios y la comparación entre puertos y nombres.
RA1.b Se han descrito los fundamentos y protocolos en los que se basa el funcionamiento de un servidor web. Apartados 4.1 y 4.8, y análisis de las respuestas curl con HTTP, Host, puertos y códigos de estado.
RA1.c Se ha realizado la instalación y configuración básica de servidores web. Apartados 4.2 a 4.7: instalación, sitios virtuales, activación, validación y recarga de Nginx.
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.8 y 5: matriz de pruebas, respuestas HTTP, funcionamiento en navegador, prueba negativa, puertos y registros del servidor web.
RA1.g Se ha analizado la estructura y recursos que componen una aplicación web. Inventario de index.html, estilos, JavaScript, raíz pública, configuración y logs en los apartados 3 y 6.
RA1.h Se han descrito los requerimientos del proceso de implantación de una aplicación web. Ficha de requisitos del apartado 3: sistema, permisos, puertos, nombres, firewall, herramientas y resultado esperado.
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. Entregable reproducible del apartado 6, con versiones, comandos, configuraciones, pruebas, incidencias y recuperación del servidor web.

3. Requisitos y recursos

3.1. Requisitos previos

  • Una máquina Debian o Ubuntu con acceso a una cuenta con sudo.
  • Conocimientos básicos de terminal, rutas absolutas, permisos, HTML y HTTP.
  • Un navegador web y, preferiblemente, curl para repetir las pruebas desde la terminal.
  • Acceso para editar el fichero de resolución local /etc/hosts del equipo cliente si eliges la diferenciación por nombre de dominio.
  • Permiso para abrir los puertos 80 y, si eliges la opción por puertos, 8080/tcp en ufw.
  • Espacio suficiente para instalar Nginx y guardar las evidencias. No utilices datos personales, contraseñas ni claves reales en las capturas o en el informe.

3.2. Recursos de consulta

mkdir -p ~/evidencias-nginx-p1

Conserva en esta carpeta las salidas de los comandos y las copias de los archivos que se indican en los pasos siguientes. No cambies los nombres: la numeración permite revisar rápidamente si la carpeta está completa.

3.3. Elige cómo diferenciarás los sitios

Debes ejecutar una de estas opciones y documentar por qué la has elegido:

Opción Dirección del sitio 1 Dirección del sitio 2 Uso recomendado
A. Puertos http://localhost http://localhost:8080 Laboratorio local o prueba rápida.
B. Nombres http://saludo.local http://repetidor.local Comprender los sitios virtuales por cabecera Host.

La opción B se aproxima mejor al funcionamiento habitual de varios dominios en un mismo puerto. La opción A es más sencilla si no puedes editar el fichero hosts o si el puerto 80 ya está reservado por otra configuración.

Ejecuta solo uno de estos comandos, según la opción que hayas elegido:

# Opción A: diferenciación por puertos
printf '%b\n' 'A. Puertos\thttp://localhost\thttp://localhost:8080\tLaboratorio local o prueba rápida.' \
  > ~/evidencias-nginx-p1/0.-opcion_elegida.txt

# Opción B: diferenciación por nombres
printf '%b\n' 'B. Nombres\thttp://saludo.local\thttp://repetidor.local\tSitios virtuales mediante la cabecera Host.' \
  > ~/evidencias-nginx-p1/0.-opcion_elegida.txt

Comprueba el contenido de la evidencia:

cat ~/evidencias-nginx-p1/0.-opcion_elegida.txt

4. Pasos a seguir

4.1. Analiza la arquitectura y registra el entorno

Antes de instalar, dibuja en el informe un esquema parecido a este y explica el recorrido de una petición:

Cliente (navegador o curl)
        │ HTTP :80 o :8080
        ▼
Nginx (bloque server y location)
        ├── /var/www/saludo-app/index.html
        └── /var/www/repetidor-app/index.html

Nginx no ejecuta el JavaScript del ejemplo. Entrega index.html; después, el navegador interpreta el HTML, el CSS y el JavaScript. Esta diferencia es importante: estamos desplegando dos aplicaciones frontend estáticas, no dos servidores de aplicaciones.

Registra el sistema y las características del entorno antes de modificarlo:

{
    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-nginx-p1/1.-entorno.txt

Completa en el informe esta ficha:

Dato Valor que debes registrar
Sistema operativo y versión
Arquitectura de CPU
CPU y memoria asignadas
Disco disponible
Dirección IP del servidor
Cliente desde el que probarás
Opción elegida: A o B
Fecha y persona que valida
Resultado válido acordado Dos sitios responden y sus funciones interactivas producen el resultado esperado.

4.2. Instala y pone en marcha Nginx

Actualiza el índice de paquetes e instala Nginx:

sudo apt update
sudo apt install nginx -y

Habilita el servicio para que arranque con el sistema, inícialo y consulta su estado:

sudo systemctl enable --now nginx
sudo systemctl status nginx

Debes localizar el estado active (running). Pulsa q para salir de la vista de estado. Comprueba también la versión:

nginx -v

Si usas ufw, permite el tráfico HTTP estándar:

sudo ufw allow 'Nginx HTTP'
sudo ufw status verbose

Si la instalación no arranca, no edites todavía los ficheros al azar. Comprueba si otro proceso utiliza el puerto 80 y consulta el registro del servicio:

sudo ss -ltnp | grep -E ':(80|443)[[:space:]]' || true
sudo journalctl -u nginx --no-pager -n 50

Guarda la evidencia de la instalación, el servicio, la versión, los puertos y el firewall:

{
    echo '=== Versión de Nginx ==='
    nginx -v
    echo '=== Servicio habilitado ==='
    sudo systemctl is-enabled nginx
    echo '=== Servicio activo ==='
    sudo systemctl is-active nginx
    echo '=== Estado resumido ==='
    sudo systemctl status nginx --no-pager
    echo '=== Puertos ==='
    sudo ss -ltnp | grep -E ':(80|8080|443)[[:space:]]' || true
    echo '=== Firewall ==='
    sudo ufw status verbose || true
} 2>&1 | tee ~/evidencias-nginx-p1/2.-instalacion-y-estado.txt

Dos procesos no pueden reservar a la vez la misma combinación de dirección y puerto. Si existe Apache u otro servidor web, documenta la decisión de detenerlo, cambiar el puerto o trabajar en otra máquina.

4.3. Reconoce la arquitectura de ficheros de Nginx

En Debian y Ubuntu es habitual encontrar esta estructura:

Ruta Tipo Función principal
/etc/nginx/ Directorio Raíz de la configuración de Nginx.
/etc/nginx/nginx.conf Archivo Configuración global: procesos, conexiones, tipos MIME, logs e inclusiones.
/etc/nginx/sites-available/ Directorio Sitios virtuales definidos, estén publicados o no.
/etc/nginx/sites-enabled/ Directorio Enlaces simbólicos a los sitios que Nginx carga activamente.
/etc/nginx/conf.d/ Directorio Fragmentos adicionales; en otras distribuciones puede ser la ubicación principal de los sitios.
/var/www/ Directorio Ubicación habitual de los archivos públicos HTML, CSS, JavaScript e imágenes.
/var/log/nginx/ Directorio Registros de acceso y error.

Comprueba las rutas y localiza qué directorios se incluyen realmente:

sudo ls -la /etc/nginx
sudo ls -la /etc/nginx/sites-available
sudo ls -la /etc/nginx/sites-enabled
sudo ls -la /etc/nginx/conf.d
sudo grep -nE 'include|access_log|error_log' /etc/nginx/nginx.conf
sudo ls -la /var/www
sudo ls -la /var/log/nginx

sites-available es el almacén de configuraciones. Crear un archivo allí no lo activa por sí mismo. En la instalación habitual de Debian, el enlace simbólico en sites-enabled es lo que hace que el sitio se incluya en la configuración efectiva. Comprueba la configuración completa cuando necesites localizar una inclusión o un sitio duplicado:

sudo nginx -T

Recoge las rutas, inclusiones y directorios relevantes en una evidencia más breve y manejable:

{
    echo '=== /etc/nginx ==='
    sudo find /etc/nginx -maxdepth 2 -type f -o -type l | sort
    echo '=== Inclusiones y registros ==='
    sudo grep -nE 'include|access_log|error_log' /etc/nginx/nginx.conf
    echo '=== /var/www ==='
    sudo find /var/www -maxdepth 2 -printf '%M %u:%g %p\n' | sort
    echo '=== /var/log/nginx ==='
    sudo ls -la /var/log/nginx
} 2>&1 | tee ~/evidencias-nginx-p1/3.-arquitectura-ficheros.txt

La salida puede ser extensa y contener rutas internas. Antes de subir la evidencia, revisa el archivo generado y elimina cualquier información que no sea necesaria para el informe.

4.4. Crea el sitio 1: saludo-app

Crea la raíz del proyecto y asigna temporalmente la propiedad a tu usuario para poder editar los archivos sin trabajar como root:

sudo mkdir -p /var/www/saludo-app
sudo chown -R "$USER:$USER" /var/www/saludo-app
nano /var/www/saludo-app/index.html

Escribe este contenido completo en 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 en Nginx</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 50px; }
        input, button { padding: 8px; font-size: 16px; }
        #resultado { margin-top: 20px; font-size: 20px; font-weight: bold; color: #2c3e50; }
    </style>
</head>
<body>

    <h2>Introduce tu nombre</h2>
    <input type="text" id="nombreInput" placeholder="Ej. Pedro">
    <button onclick="saludar()">Aceptar</button>

    <div id="resultado"></div>

    <script>
        function saludar() {
            const nombre = document.getElementById('nombreInput').value.trim();
            const contenedor = document.getElementById('resultado');

            if (nombre !== "") {
                contenedor.textContent = "Hola " + nombre + "!!";
            } else {
                contenedor.textContent = "Por favor, escribe un nombre.";
            }
        }
    </script>

</body>
</html>

En nano, guarda con Ctrl + O, pulsa Enter y sal con Ctrl + X. No confundas la raíz pública con el archivo de configuración: aquí estás creando el recurso que Nginx entregará al navegador.

Conserva una copia y una descripción verificable del primer sitio:

{
    echo '=== Archivo ==='
    stat /var/www/saludo-app/index.html
    echo '=== SHA-256 ==='
    sha256sum /var/www/saludo-app/index.html
    echo '=== Contenido ==='
    sed -n '1,240p' /var/www/saludo-app/index.html
} 2>&1 | tee ~/evidencias-nginx-p1/4.-saludo-app.txt
cp /var/www/saludo-app/index.html ~/evidencias-nginx-p1/4.-saludo-app.index.html

4.5. Crea el sitio 2: repetidor-app

Prepara la segunda raíz y abre su archivo principal:

sudo mkdir -p /var/www/repetidor-app
sudo chown -R "$USER:$USER" /var/www/repetidor-app
nano /var/www/repetidor-app/index.html

Escribe el siguiente contenido:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Repetidor Hola Mundo</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 50px; }
        input, button { padding: 8px; font-size: 16px; }
        #salida { margin-top: 20px; line-height: 1.6; }
    </style>
</head>
<body>

    <h2>Repetidor de Hola Mundo</h2>
    <input type="number" id="cantidadInput" min="1" max="100" placeholder="Ej. 5">
    <button onclick="repetir()">Generar</button>

    <div id="salida"></div>

    <script>
        function repetir() {
            const cantidad = parseInt(document.getElementById('cantidadInput').value);
            const contenedor = document.getElementById('salida');
            contenedor.innerHTML = "";

            if (isNaN(cantidad) || cantidad <= 0) {
                contenedor.textContent = "Por favor, introduce un número válido mayor que 0.";
                return;
            }

            for (let i = 0; i < cantidad; i++) {
                const linea = document.createElement('div');
                linea.textContent = (i + 1) + ". ¡Hola mundo!";
                contenedor.appendChild(linea);
            }
        }
    </script>

</body>
</html>

Guarda y cierra con Ctrl + O, Enter y Ctrl + X. Comprueba que ambos archivos existen y registra su tamaño o una copia de su contenido en las evidencias:

{
    echo '=== Archivo ==='
    stat /var/www/repetidor-app/index.html
    echo '=== SHA-256 ==='
    sha256sum /var/www/repetidor-app/index.html
    echo '=== Contenido ==='
    sed -n '1,260p' /var/www/repetidor-app/index.html
} 2>&1 | tee ~/evidencias-nginx-p1/5.-repetidor-app.txt
cp /var/www/repetidor-app/index.html ~/evidencias-nginx-p1/5.-repetidor-app.index.html

4.6. Configura los sitios virtuales: opción A, por puertos

Elige este apartado si quieres publicar saludo-app en el puerto 80 y repetidor-app en el puerto 8080. Edita el primer sitio:

sudo nano /etc/nginx/sites-available/saludo-app

Escribe:

server {
    listen 80;
    server_name localhost;

    root /var/www/saludo-app;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Edita el segundo sitio:

sudo nano /etc/nginx/sites-available/repetidor-app

Escribe:

server {
    listen 8080;
    server_name localhost;

    root /var/www/repetidor-app;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

En esta opción listen diferencia los sitios. Si el cortafuegos está activo, abre también el puerto 8080:

sudo ufw allow 8080/tcp
sudo ufw status verbose

Si no utilizas ufw, documenta qué firewall o regla de red permite la conexión, o indica que las pruebas se realizan únicamente desde el propio servidor.

4.7. Configura los sitios virtuales: opción B, por nombres

Elige este apartado si quieres que ambos sitios escuchen en el puerto 80 y que Nginx seleccione el sitio mediante la cabecera HTTP Host.

Configura saludo-app:

sudo nano /etc/nginx/sites-available/saludo-app
server {
    listen 80;
    server_name saludo.local;

    root /var/www/saludo-app;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Configura repetidor-app:

sudo nano /etc/nginx/sites-available/repetidor-app
server {
    listen 80;
    server_name repetidor.local;

    root /var/www/repetidor-app;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

En el equipo desde el que abrirás el navegador, añade ambos nombres al fichero hosts. Si el cliente es el propio servidor, edita /etc/hosts; si es Windows, edita C:\Windows\System32\drivers\etc\hosts como administrador.

Para un cliente Linux:

sudo nano /etc/hosts

Añade una línea como esta, cambiando 127.0.0.1 por la IP privada del servidor cuando accedas desde otra máquina:

127.0.0.1 saludo.local repetidor.local

Comprueba la resolución:

getent hosts saludo.local repetidor.local

No combines las dos opciones sin una decisión documentada: si dejas el puerto 8080 del ejemplo A y además intentas usarlo para otra función, puedes crear un conflicto difícil de interpretar.

4.8. Activa los sitios, valida y recarga Nginx

Crea los enlaces simbólicos de los sitios disponibles a los sitios habilitados:

sudo ln -s /etc/nginx/sites-available/saludo-app /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/repetidor-app /etc/nginx/sites-enabled/

Desactiva el sitio de bienvenida para evitar que responda como sitio predeterminado. Si ya no existe, puedes anotar que estaba desactivado:

sudo unlink /etc/nginx/sites-enabled/default

Comprueba los enlaces y valida antes de recargar:

sudo ls -la /etc/nginx/sites-enabled
sudo nginx -t

La salida correcta debe incluir syntax is ok y test is successful. Si hay un error, lee la ruta y la línea indicadas, corrige un cambio cada vez y repite sudo nginx -t. No uses reload mientras la validación falle.

Recarga el servicio sin detenerlo y consulta su estado:

sudo systemctl reload nginx
sudo systemctl status nginx --no-pager

Después de recargar, guarda copias numeradas de las configuraciones usadas y una validación de la configuración efectiva, sin incluir secretos:

sudo cp /etc/nginx/sites-available/saludo-app \
  ~/evidencias-nginx-p1/6.-saludo-app.conf
sudo cp /etc/nginx/sites-available/repetidor-app \
  ~/evidencias-nginx-p1/7.-repetidor-app.conf
sudo chown "$USER:$USER" ~/evidencias-nginx-p1/6.-saludo-app.conf \
  ~/evidencias-nginx-p1/7.-repetidor-app.conf

set -o pipefail
{
    echo '=== Enlaces habilitados ==='
    sudo ls -la /etc/nginx/sites-enabled
    echo '=== Destinos de los enlaces ==='
    sudo readlink -f /etc/nginx/sites-enabled/saludo-app
    sudo readlink -f /etc/nginx/sites-enabled/repetidor-app
    echo '=== Validación de sintaxis ==='
    sudo nginx -t
} 2>&1 | tee ~/evidencias-nginx-p1/8.-activacion-y-validacion.txt
resultado_validacion=$?
set +o pipefail
if [ "$resultado_validacion" -ne 0 ]; then
    echo "La validación ha fallado; no se debe recargar Nginx." >&2
    exit "$resultado_validacion"
fi

{
    echo '=== Recarga ==='
    date --iso-8601=seconds
    sudo systemctl reload nginx
    echo '=== Estado activo ==='
    sudo systemctl is-active nginx
    echo '=== Estado habilitado ==='
    sudo systemctl is-enabled nginx
    echo '=== Estado del servicio ==='
    sudo systemctl status nginx --no-pager
} 2>&1 | tee ~/evidencias-nginx-p1/9.-recarga-y-estado.txt

sudo nginx -T > ~/evidencias-nginx-p1/10.-nginx-configuracion-efectiva.txt 2>&1
sudo chown "$USER:$USER" ~/evidencias-nginx-p1/10.-nginx-configuracion-efectiva.txt

4.9. Verifica los dos sitios desde el cliente

El siguiente bloque lee la opción guardada en 0.-opcion_elegida.txt y guarda las respuestas HTTP de los dos sitios en una única evidencia:

{
    echo '=== Opción elegida ==='
    cat ~/evidencias-nginx-p1/0.-opcion_elegida.txt
    if grep -q '^A\.' ~/evidencias-nginx-p1/0.-opcion_elegida.txt; then
        echo '=== saludo-app: http://localhost/ ==='
        curl --include --silent --show-error --max-time 10 http://localhost/
        echo '=== repetidor-app: http://localhost:8080/ ==='
        curl --include --silent --show-error --max-time 10 http://localhost:8080/
    else
        echo '=== saludo-app: http://saludo.local/ ==='
        curl --include --silent --show-error --max-time 10 http://saludo.local/
        echo '=== repetidor-app: http://repetidor.local/ ==='
        curl --include --silent --show-error --max-time 10 http://repetidor.local/
        echo '=== Selección mediante Host desde el servidor ==='
        curl --include --silent --show-error --header 'Host: saludo.local' http://127.0.0.1/
        curl --include --silent --show-error --header 'Host: repetidor.local' http://127.0.0.1/
    fi
} 2>&1 | tee ~/evidencias-nginx-p1/11.-pruebas-http.txt

En cada respuesta comprueba que aparece HTTP/1.1 200 OK y que el cuerpo contiene el título o texto del sitio correcto. Después abre las URL en el navegador y realiza las pruebas funcionales:

  1. En saludo-app, introduce Pedro y pulsa Aceptar. Debe aparecer Hola Pedro!!. Si dejas el campo vacío, debe aparecer «Por favor, escribe un nombre.».
  2. En repetidor-app, introduce 4 y pulsa Generar. Deben aparecer cuatro líneas numeradas de ¡Hola mundo!.
  3. Introduce 0, un campo vacío o un valor no válido en el repetidor. Debe aparecer el mensaje de validación y no deben generarse líneas.

Después de realizar las pruebas en el navegador, crea una ficha breve y complétala con el resultado observado:

cat > ~/evidencias-nginx-p1/12.-pruebas-funcionales.txt <<'EOF'
# Completa los campos Resultado observado y Estado.

## saludo-app — entrada Pedro
Resultado esperado: Hola Pedro!!
Resultado observado:
Estado: PASS / FAIL

## saludo-app — campo vacío
Resultado esperado: Por favor, escribe un nombre.
Resultado observado:
Estado: PASS / FAIL

## repetidor-app — entrada 4
Resultado esperado: cuatro líneas numeradas de ¡Hola mundo!.
Resultado observado:
Estado: PASS / FAIL

## repetidor-app — entrada 0 o vacía
Resultado esperado: mensaje de validación y ninguna línea.
Resultado observado:
Estado: PASS / FAIL
EOF
nano ~/evidencias-nginx-p1/12.-pruebas-funcionales.txt

Si accedes desde otro ordenador de la red local, sustituye localhost por la dirección obtenida con hostname -I y recuerda que el fichero hosts y las reglas del firewall pertenecen al equipo cliente y al servidor, respectivamente.

4.10. Observa los registros y conserva evidencias

Después de realizar varias peticiones, consulta los registros:

{
    echo '=== Fecha de consulta ==='
    date --iso-8601=seconds
    echo '=== Access log ==='
    sudo tail -n 30 /var/log/nginx/access.log
    echo '=== Error log ==='
    sudo tail -n 30 /var/log/nginx/error.log
    echo '=== Journal de Nginx ==='
    sudo journalctl -u nginx --since '10 minutes ago' --no-pager
} 2>&1 | tee ~/evidencias-nginx-p1/13.-registros.txt

Relaciona al menos una petición de cada sitio con una línea del access.log. Si el registro de error está vacío, eso puede ser un resultado correcto; indica que se ha revisado y que no había errores durante la prueba. No confundas nginx -t con una prueba funcional: la primera orden valida sintaxis y la segunda demuestra que el cliente recibe una respuesta.

4.11. Genera el índice de evidencias

Cuando hayas creado todos los archivos anteriores, genera el README.md de la carpeta. Sus enlaces son relativos, por lo que seguirán funcionando cuando subas la carpeta al repositorio:

cat > ~/evidencias-nginx-p1/README.md <<'EOF'
# Evidencias — Práctica 1 de Nginx

Cada archivo contiene la salida o la transcripción de una comprobación de la
práctica. La numeración facilita revisar el proceso en orden.

| Nº | Evidencia | Contenido |
|---:|---|---|
| 0 | [Opción elegida](0.-opcion_elegida.txt) | Forma de diferenciar los sitios. |
| 1 | [Entorno](1.-entorno.txt) | Sistema, CPU, memoria, disco e IP. |
| 2 | [Instalación y estado](2.-instalacion-y-estado.txt) | Versión, servicio, puertos y firewall. |
| 3 | [Arquitectura de ficheros](3.-arquitectura-ficheros.txt) | Rutas, inclusiones y registros. |
| 4 | [Saludo app](4.-saludo-app.txt) | Metadatos y contenido de `saludo-app`. |
| 5 | [Repetidor app](5.-repetidor-app.txt) | Metadatos y contenido de `repetidor-app`. |
| 4c | [HTML de saludo](4.-saludo-app.index.html) | Copia del archivo publicado. |
| 5c | [HTML de repetidor](5.-repetidor-app.index.html) | Copia del archivo publicado. |
| 6 | [Configuración de saludo](6.-saludo-app.conf) | Sitio virtual de `saludo-app`. |
| 7 | [Configuración de repetidor](7.-repetidor-app.conf) | Sitio virtual de `repetidor-app`. |
| 8 | [Activación y validación](8.-activacion-y-validacion.txt) | Enlaces y `nginx -t`. |
| 9 | [Recarga y estado](9.-recarga-y-estado.txt) | Recarga y estado final. |
| 10 | [Configuración efectiva](10.-nginx-configuracion-efectiva.txt) | Configuración cargada por Nginx. |
| 11 | [Pruebas HTTP](11.-pruebas-http.txt) | Respuestas de los dos sitios. |
| 12 | [Pruebas funcionales](12.-pruebas-funcionales.txt) | Resultados observados en el navegador. |
| 13 | [Registros](13.-registros.txt) | `access.log`, `error.log` y `journal`. |
| 14 | [Inventario y validación](14.-inventario-y-validacion.txt) | Archivos presentes y enlaces revisados. |

Si añades otros archivos, incorpora también su enlace en esta tabla.
EOF

El informe puede redactarse fuera de esta carpeta. Por ejemplo, si el informe y evidencias-nginx-p1/ se suben al mismo directorio, sus enlaces pueden ser:

nano ~/informe-nginx-p1.md

Desde informe-nginx-p1.md, enlaza evidencias-nginx-p1/README.md y los archivos de evidencia que necesites. No copies de nuevo sus salidas ni las transcribas varias veces.

Finalmente, comprueba que las evidencias existen y que el README.md contiene sus enlaces:

evidencias="$HOME/evidencias-nginx-p1"
{
    echo '=== Inventario ==='
    find "$evidencias" -maxdepth 1 -type f -printf '%f\n' | sort -V
    echo '=== Archivos requeridos ==='
    for archivo in \
        0.-opcion_elegida.txt \
        1.-entorno.txt \
        2.-instalacion-y-estado.txt \
        3.-arquitectura-ficheros.txt \
        4.-saludo-app.txt 4.-saludo-app.index.html \
        5.-repetidor-app.txt 5.-repetidor-app.index.html \
        6.-saludo-app.conf 7.-repetidor-app.conf \
        8.-activacion-y-validacion.txt 9.-recarga-y-estado.txt \
        10.-nginx-configuracion-efectiva.txt 11.-pruebas-http.txt \
        12.-pruebas-funcionales.txt 13.-registros.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/14.-inventario-y-validacion.txt"

5. Comprobaciones de finalización

Marca cada comprobación cuando tengas una evidencia guardada en el informe o en ~/evidencias-nginx-p1/:

  • El sistema operativo, la IP, la versión de Nginx y el tipo de entorno están registrados.
  • nginx aparece como active (running) y está habilitado para iniciar con el sistema.
  • Las carpetas /var/www/saludo-app y /var/www/repetidor-app contienen su index.html y tienen permisos de lectura para Nginx.
  • Se ha explicado la diferencia entre sites-available y sites-enabled, y se han comprobado los include reales.
  • Los dos archivos de sitio tienen un bloque server, una raíz o proxy explícito y un location comprensible.
  • sudo nginx -t termina con syntax is ok y test is successful.
  • Los enlaces simbólicos de los sitios aparecen en sites-enabled y el sitio por defecto no responde accidentalmente.
  • Las dos URL devuelven HTTP 200 y cada una entrega el index.html que le corresponde.
  • Se ha comprobado en el navegador la interacción de saludo y repetición, incluyendo al menos un caso válido y uno no válido.
  • Se ha ejecutado una prueba negativa de una ruta inexistente y se ha interpretado el HTTP 404.
  • Las peticiones aparecen en el registro de acceso y se ha revisado el registro de error.
  • El informe contiene el diagrama, la ficha de requisitos, la matriz de pruebas, los resultados y las incidencias.
  • La carpeta contiene las evidencias numeradas del 0 al 14, las copias de los HTML y las configuraciones indicadas en el README.md.
  • README.md enlaza mediante rutas relativas cada archivo de evidencia y se ha comprobado que los enlaces funcionan después de copiar la carpeta. Una instalación no se considera terminada solo porque el servicio esté encendido. La finalización exige combinar proceso, configuración, respuesta HTTP, comportamiento de la aplicación y registros.

6. Ejercicios y entregables

6.1. Ejercicios de análisis

  1. Arquitectura: entrega un diagrama propio y explica qué componente genera cada parte de la respuesta. Indica qué ocurre en el navegador y qué ocurre en Nginx.
  2. Comparación de selección: compara la opción A y la opción B. Explica qué diferencia listen, qué diferencia server_name, qué información viaja en Host y qué ventajas e inconvenientes tiene cada alternativa.
  3. HTTP: analiza la salida de curl --include de ambos sitios. Identifica la línea de estado, al menos tres cabeceras y el cuerpo HTML. Explica por qué un HTTP 200 no demuestra por sí solo que el botón de JavaScript funcione.
  4. Estructura web: inventaría los recursos de cada aplicación: HTML, CSS embebido, JavaScript, raíz pública, configuración de Nginx y registros. Indica cuáles son estáticos y dónde se ejecutan.
  5. Diagnóstico: provoca de forma reversible un error de ruta, registra el HTTP 404 y explica qué comprobarías si apareciera un HTTP 403, 502 o 503.
  6. Seguridad y mantenimiento: explica por qué no debes guardar secretos en /var/www, por qué conviene validar antes de recargar y qué copia de recuperación conservarías antes de modificar un sitio.

6.2. Entregables

Entrega el informe y la carpeta evidencias-nginx-p1/ en el mismo directorio. La carpeta contiene únicamente el README.md y los archivos numerados generados durante la práctica. El informe enlaza las evidencias existentes; no copies de nuevo sus salidas ni las transcribas varias veces.

El informe debe incluir:

  1. Portada o cabecera con nombre, fecha, sistema operativo, versión de Nginx y opción elegida.
  2. Objetivo y alcance de la práctica.
  3. Diagrama de arquitectura y explicación del recorrido de una petición.
  4. Ficha de requisitos y recursos, incluyendo puertos, nombres, permisos, firewall y cliente de prueba.
  5. Resumen de los comandos de instalación y comprobaciones, con enlace a 2.-instalacion-y-estado.txt.
  6. Tabla de rutas de Nginx y explicación de nginx.conf, sites-available, sites-enabled, /var/www y los logs.
  7. Enlaces a los HTML publicados: 4.-saludo-app.index.html y 5.-repetidor-app.index.html.
  8. Enlaces a 6.-saludo-app.conf y 7.-repetidor-app.conf, indicando si se usó la opción A o B.
  9. Enlaces a 8.-activacion-y-validacion.txt, 9.-recarga-y-estado.txt y 11.-pruebas-http.txt.
  10. Enlaces a 12.-pruebas-funcionales.txt y 13.-registros.txt. Oculta en esos archivos nombres de usuario, IP públicas y cualquier secreto que aparezca por accidente.
  11. Matriz de pruebas con ID, precondiciones, acción, resultado esperado, resultado obtenido, estado (PASS, FAIL, BLOCKED o N/A) y nombre del archivo de evidencia asociado.
  12. Respuestas a los ejercicios de análisis y una relación explícita de cada evidencia con RA1 y sus criterios.
  13. Incidencias encontradas, causa, solución, prueba de cierre y procedimiento de recuperación, enlazando los archivos que lo demuestren.

Organiza las evidencias de la práctica dentro de la carpeta evidencias-nginx-p1/, con la siguiente estructura:

evidencias-nginx-p1/
├── README.md
├── 0.-opcion_elegida.txt
├── 1.-entorno.txt
├── 2.-instalacion-y-estado.txt
├── 3.-arquitectura-ficheros.txt
├── 4.-saludo-app.txt
├── 4.-saludo-app.index.html
├── 5.-repetidor-app.txt
├── 5.-repetidor-app.index.html
├── 6.-saludo-app.conf
├── 7.-repetidor-app.conf
├── 8.-activacion-y-validacion.txt
├── 9.-recarga-y-estado.txt
├── 10.-nginx-configuracion-efectiva.txt
├── 11.-pruebas-http.txt
├── 12.-pruebas-funcionales.txt
├── 13.-registros.txt
└── 14.-inventario-y-validacion.txt

No es necesario copiar todo /etc/nginx. El archivo 10.-nginx-configuracion-efectiva.txt conserva la salida de nginx -T para facilitar la revisión; antes de subir la carpeta, elimina cualquier dato personal, dirección pública o información sensible que aparezca por accidente.

7. Solución orientativa

La siguiente guía permite contrastar el resultado, pero no sustituye a las evidencias de tu propio equipo.

7.1. Estructura esperada

Después de completar la parte principal deberían existir, como mínimo:

/var/www/
├── saludo-app/
│   └── index.html
└── repetidor-app/
    └── index.html

/etc/nginx/sites-available/
├── saludo-app
└── repetidor-app

/etc/nginx/sites-enabled/
├── saludo-app -> ../sites-available/saludo-app
└── repetidor-app -> ../sites-available/repetidor-app

El enlace default puede no aparecer porque se ha desactivado para que la respuesta no sea la página de bienvenida.

La solución de referencia del repositorio separa las dos alternativas para que puedan consultarse sin mezclar configuraciones ni evidencias:

practica001.solucion/
├── modoA/
│   ├── informe-nginx-p1.md
│   └── evidencias-nginx-p1/
└── modoB/
    ├── informe-nginx-p1.md
    └── evidencias-nginx-p1/

7.2. Resultado esperado de la configuración

En la opción A, saludo-app escucha en 80 y tiene como raíz /var/www/saludo-app; repetidor-app escucha en 8080 y tiene como raíz /var/www/repetidor-app. En la opción B, ambos escuchan en 80, pero el primero tiene server_name saludo.local y el segundo server_name repetidor.local.

En ambos casos, try_files $uri $uri/ =404; hace que una ruta inexistente termine en 404 en vez de seleccionar un archivo inesperado. El archivo index.html se busca porque se ha declarado index index.html;.

7.3. Validación y pruebas esperadas

La validación correcta se parece a:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Las respuestas de las dos URL deben empezar por un estado 200 y contener el HTML correspondiente. Una prueba funcional correcta produce resultados parecidos a estos:

Aplicación Entrada Resultado esperado
saludo-app Pedro Hola Pedro!!
saludo-app Vacía Por favor, escribe un nombre.
repetidor-app 4 Cuatro líneas numeradas de ¡Hola mundo!.
repetidor-app 0, vacío o no numérica Mensaje de número válido y ninguna línea generada.
Cualquier sitio /ruta-que-no-existe HTTP 404.

El access.log debería registrar las peticiones a / y a los recursos solicitados. Un error.log sin nuevas líneas durante una ejecución correcta es compatible con un resultado PASS, siempre que se indique que se ha revisado.

7.4. Respuestas conceptuales orientativas

  • Nginx es el servidor web y punto de entrada; entrega archivos estáticos y selecciona el bloque server por puerto y, cuando corresponde, por la cabecera Host.
  • sites-available contiene definiciones y sites-enabled contiene enlaces a las definiciones activas. Un archivo disponible no se sirve hasta que la configuración efectiva lo incluye.
  • nginx -t comprueba sintaxis y archivos accesibles; no prueba que una persona cliente reciba la URL ni que la interacción JavaScript funcione. Para cerrar la verificación hay que combinar curl, navegador y registros.
  • Un 404 indica que la ruta solicitada no se ha encontrado; un 403 suele apuntar a permisos o a una política de acceso; un 502 suele aparecer cuando un proxy no alcanza su backend; un 503 indica que el servicio no está disponible o no puede atender en ese momento.
  • La opción A es útil para pruebas rápidas, pero obliga a recordar un puerto por sitio. La opción B se parece más al alojamiento de dominios, pero necesita resolución de nombres correcta y una cabecera Host coincidente.

7.5. Estructura esperada de las evidencias

La carpeta final debe permitir revisar el proceso sin ejecutar de nuevo todos los comandos. Como mínimo, debe contener:

evidencias-nginx-p1/
├── README.md
├── 0.-opcion_elegida.txt
├── 1.-entorno.txt
├── 2.-instalacion-y-estado.txt
├── 3.-arquitectura-ficheros.txt
├── 4.-saludo-app.txt
├── 4.-saludo-app.index.html
├── 5.-repetidor-app.txt
├── 5.-repetidor-app.index.html
├── 6.-saludo-app.conf
├── 7.-repetidor-app.conf
├── 8.-activacion-y-validacion.txt
├── 9.-recarga-y-estado.txt
├── 10.-nginx-configuracion-efectiva.txt
├── 11.-pruebas-http.txt
├── 12.-pruebas-funcionales.txt
├── 13.-registros.txt
└── 14.-inventario-y-validacion.txt

El README.md debe enlazar los archivos con sus nombres exactos. Si falta un número, comprueba qué paso no se ejecutó o documenta la incidencia en el informe.

8. Fuentes y referencias

En Debian y Ubuntu, las carpetas sites-available/ y sites-enabled/ forman parte de la convención de configuración del paquete de la distribución. Las instalaciones realizadas directamente desde los repositorios de nginx.org pueden utilizar principalmente /etc/nginx/conf.d/; por eso conviene comprobar qué rutas incluye realmente /etc/nginx/nginx.conf antes de aplicar una guía.