Unidad 2: ¿Qué tengo que saber?

Usa esta lista para repasar la unidad. Ve marcando lo que ya dominas: se guarda en tu navegador, así que lo verás marcado cuando vuelvas desde el mismo equipo. Si no puedes marcar algún punto, vuelve a la presentación o al ejercicio correspondiente.

El protocolo HTTP

• Sé explicar los cuatro niveles de TCP/IP (aplicación, transporte, red y enlace), qué resuelve cada uno y qué dirección usa (URL y Host, puerto, IP, MAC).
• Sé explicar el encapsulamiento y qué cabecera lee cada equipo (switch, router, servidor web): por qué el router no ve la URL ni el Host.
• Sé explicar qué es HTTP: un protocolo de la capa de aplicación, de petición y respuesta, y sin estado.
• Identifico en qué puertos trabajan HTTP y HTTPS, y qué transporte usa cada versión (TCP en HTTP/1.1 y HTTP/2, QUIC sobre UDP en HTTP/3).
• ¿Sé diferenciar HTTP/1.1, HTTP/2 y HTTP/3, y qué es lo que no cambia entre ellas (métodos, códigos de estado y cabeceras)?
• Sé explicar cómo se establece una conexión TCP (saludo en tres pasos) y por qué las conexiones persistentes (keep-alive) ahorran tiempo.

La URL

• Identifico las partes de una URL: esquema, host, puerto, ruta, consulta y fragmento.
• Sé explicar qué parte de la URL va en la línea de petición, cuál en la cabecera Host y cuál no se envía al servidor.

Los mensajes HTTP

• Identifico la estructura de una petición: línea inicial (método, recurso y versión), cabeceras, línea vacía y cuerpo.
• Identifico la estructura de una respuesta: línea de estado (versión, código y descripción), cabeceras, línea vacía y cuerpo.
• Sé leer una petición y su respuesta en la salida de curl -v: qué envía el cliente (>) y qué responde el servidor (<).

Métodos

• Sé explicar para qué sirven GET, HEAD, POST, PUT y DELETE.
• ¿Sé diferenciar dónde viajan los datos con GET (en la URL) y con POST (en el cuerpo)?
• Sé explicar por qué no se envían contraseñas por GET (quedan en el historial y en el access.log) y por qué POST tampoco las protege sin HTTPS.
• Sé explicar qué significa que GET y HEAD son métodos seguros.

Códigos de estado

• Identifico las cinco familias de códigos (1xx a 5xx) y qué indica cada una.
• Sé explicar los códigos que más se ven administrando un servidor: 200, 301, 302, 304, 401, 403, 404, 500, 502, 503 y 504.
• ¿Sé diferenciar 401 de 403, y 502 de 504?
• ¿Sé diferenciar una redirección permanente (301) de una temporal (302)?

Cabeceras

• Identifico las cabeceras más habituales de la petición (Host, User-Agent, Accept, Cookie, Authorization) y de la respuesta (Content-Type, Content-Length, Server, Set-Cookie, Location, Cache-Control).
• Sé explicar por qué Host es obligatoria en HTTP/1.1 y qué tiene que ver con los virtual hosts.
• Sé explicar para qué sirve Location en una redirección.
• Sé explicar por qué en producción se suele ocultar la versión que aparece en Server.

Cookies y sesiones

• Sé explicar para qué sirven las cookies y cómo funcionan: el servidor la crea con Set-Cookie y el navegador la devuelve con Cookie.
• Identifico para qué sirven los atributos de una cookie: Max-Age/Expires, Path/Domain, HttpOnly y Secure.
• Sé explicar cómo se mantiene una sesión en un protocolo sin estado: qué guarda el servidor y qué guarda el cliente.
• ¿Sé diferenciar una cookie de una sesión?

Aplicaciones que usan HTTP

• Sé explicar qué hace un servidor web y qué diferencia hay entre una página estática y una dinámica.
• ¿Sé diferenciar un proxy de un proxy inverso: en nombre de quién actúa cada uno y para qué se usa?
• ¿Sé diferenciar DNAT de un proxy inverso: en qué nivel trabaja cada uno, qué mira para decidir y cuántas conexiones TCP hay?
• Sé explicar qué es un balanceador de carga y su relación con el proxy inverso.
• Identifico ejemplos de software de cada uno (Squid, Apache, Nginx, HAProxy…).

Peticiones con curl

• Sé hacer con curl una petición GET, ver solo las cabeceras (-I), seguir una redirección (-L) y ver todo el intercambio (-v).
• Sé enviar datos a una página con GET (en la URL) y con POST (-X POST -d), y comprobar la diferencia.
• Sé ver con las herramientas para desarrolladores del navegador cuántas peticiones hace una página y sus cabeceras.

Servidores web: conceptos comunes

• Sé explicar qué es un virtual host y cómo elige el servidor el sitio que responde: por la cabecera Host, y el sitio por defecto si no coincide con ninguno (por ejemplo, al entrar por la IP).
• Sé probar varios virtual hosts sin DNS: con el /etc/hosts del cliente o con curl -H "Host: …".
• Sé explicar qué fichero busca el servidor para una URL a partir del directorio raíz, y qué responde en cada caso: el fichero (200), el índice, el listado o un 403 si no hay índice, un 301 si falta la barra de un directorio, y un 404 si no existe.
• Sé explicar por qué el servidor atiende las peticiones con www-data y qué permisos necesita (lectura en los ficheros y paso, x, en todos los directorios de la ruta).
• Sé explicar para qué sirve un alias.
• ¿Sé diferenciar una redirección (3xx con Location, la URL cambia) de una reescritura (interna, la URL no cambia)?
• Sé explicar cómo funciona la autenticación básica (401, Authorization: Basic) y por qué Base64 no protege la contraseña.
• Sé explicar qué criterios puede usar el control de acceso y qué código devuelve si deniega el acceso (403).
• Sé leer una línea del access.log (IP, usuario, fecha, línea de petición, código de estado…) y sé para qué sirve el error.log.

Apache

• Sé explicar qué es un MPM y en qué se diferencian prefork, worker y event, y por qué al instalar mod_php Debian cambia a prefork.
• Identifico para qué sirve cada parte de /etc/apache2/ (ports.conf, sites-*, mods-*, conf-*) y sé activar sitios y módulos (a2ensite, a2enmod).
• Sé comprobar la configuración antes de recargar (apache2ctl configtest, -S, -M) y la diferencia entre reload y restart.
• Sé crear un virtual host (ServerName, ServerAlias, DocumentRoot, logs propios) y explicar por qué responde 000-default si el Host no coincide.
• Sé cambiar el puerto en el que escucha un sitio.
• Sé explicar para qué sirven Options, AllowOverride y Require en un <Directory>, y por qué un DocumentRoot o un alias fuera de /var/www da 403.
• Sé configurar un Alias y una redirección con Redirect, y sé explicar por qué Redirect "/" produce un bucle y se usa RedirectMatch "^/$".
• Sé configurar la autenticación básica (htpasswd, AuthType Basic, Require valid-user) y el control de acceso con Require ip.
• ¿Sé diferenciar <RequireAny> de <RequireAll>?
• Sé explicar para qué sirve un .htaccess y por qué no funciona con AllowOverride None.
• Sé escribir una reescritura con mod_rewrite (RewriteRule … [L]) y convertirla en redirección con [R=301].
• Sé ocultar la versión del servidor (ServerTokens, ServerSignature) y cambiar el formato del log (LogFormat).

Nginx

• Sé explicar el modelo orientado a eventos de Nginx y en qué se diferencia de Apache con prefork.
• Identifico la estructura de /etc/nginx/ y sé activar un sitio (enlace en sites-enabled/, nginx -t, reload).
• Sé crear un server block (listen, server_name, root, index) y explicar qué hace try_files.
• Sé explicar qué sitio responde si el Host no coincide con ningún server_name (default_server).
• Sé explicar cómo elige Nginx el bloque location (exacta, prefijo más largo, ^~ y expresiones regulares) y predecir cuál responde a una URL.
• ¿Sé diferenciar root (añade la URL completa) de alias (sustituye el prefijo)?
• Sé configurar la autenticación básica (auth_basic) y el control de acceso por IP (allow/deny, en orden), y combinarlos con satisfy any.
• Sé redirigir con return (toda la web o solo la raíz con location = /) y reescribir con rewrite (last, permanent).
• Sé explicar cómo ejecuta Nginx el PHP (PHP-FPM, FastCGI y el socket de fastcgi_pass).
• Sé usar snippets y cambiar el formato del log (log_format, $http_<cabecera>).

Equivalencias y problemas frecuentes

• Sé traducir la configuración básica de Apache a Nginx y al revés (sitio, nombre, raíz, sitio por defecto, alias, listado, redirección, reescritura, acceso por IP, autenticación, PHP).
• Sé tener Apache y Nginx a la vez en puertos distintos y comprobar con ss -tlnp qué proceso escucha en cada uno.
• Sé investigar un 403, un 404, un 500 o un 502, por qué sale otro sitio o por qué no arranca el servidor (sintaxis, puerto ocupado), mirando el error.log.

Proxy inverso

• Sé explicar qué hace un proxy inverso y por qué, para el backend, el cliente es el proxy (la conexión TCP la abre el proxy).
• Identifico casos de uso del proxy inverso: ocultar los backends, publicar varias aplicaciones con un solo nombre o IP, terminación TLS, caché…
• Sé explicar qué problema hay con la cabecera Host que llega al backend cuando tiene virtual hosts por nombre, y cómo se resuelve (ProxyPreserveHost en Apache, proxy_set_header Host o proxy_params en Nginx).
• Sé explicar por qué hay que reescribir la cabecera Location de las redirecciones del backend (ProxyPassReverse en Apache; en Nginx lo hace proxy_redirect default).
• Sé explicar por qué una aplicación publicada en una subruta puede salir rota (rutas absolutas como /css/estilo.css) y por qué los enlaces relativos sí funcionan.
• Sé configurar un proxy inverso con Apache (mod_proxy, ProxyPass, ProxyPassReverse) y con Nginx (proxy_pass, include proxy_params).
• Sé explicar qué cambia la barra final de proxy_pass en Nginx (quitar el prefijo de la subruta o pasar la URL entera) y por qué /shop sin barra se redirige a /shop/.
• Sé explicar para qué sirven las cabeceras X-Forwarded-For, X-Real-IP y X-Forwarded-Proto.

Balanceo de carga con HAProxy

• ¿Sé diferenciar los algoritmos de balanceo estáticos (round robin, ponderado, afinidad, hash) de los dinámicos (conexiones mínimas, menor tiempo de respuesta)?
• Identifico las secciones de haproxy.cfg (global, defaults, frontend, backend, listen) y sé configurar un balanceador con dos servidores.
• Sé comprobar la configuración de haproxy antes de aplicarla (haproxy -c -f) y ver sus mensajes en el journal.
• Sé explicar cómo funcionan los health checks (check, inter, fall, rise), qué pasa cuando cae un servidor y por qué, si caen todos, responde 503.
• Sé explicar por qué el servidor web ve la IP del balanceador y cómo registrar la IP real del cliente (option forwardfor y el formato del log).
• Sé explicar por qué se pierde una sesión de PHP sin afinidad y cómo la mantiene haproxy con una cookie (cookie SERVERID insert).
• Sé configurar la página de estadísticas de haproxy con autenticación y explicar qué muestra (UP, DOWN, MAINT).
• ¿Sé diferenciar la función del proxy inverso (decide adónde va cada petición por el nombre o la ruta) de la del balanceador (reparte entre servidores que sirven lo mismo)?

Tipos de almacenamiento

• ¿Sé diferenciar DAS, NAS, SAN y almacenamiento en la nube: cómo se accede, qué se comparte (bloques, ficheros u objetos) y para qué se usa cada uno?
• Sé explicar dónde está el sistema de ficheros en una NAS (en el servidor) y en una SAN (en el cliente, que formatea el disco).
• Sé explicar por qué un disco de una SAN no se debe montar a la vez en dos clientes con un sistema de ficheros tradicional y por qué un directorio NFS sí se puede compartir.

RAID 5 y LVM

• Sé explicar cómo funciona un RAID 5 (datos y paridad repartidos), cuántos discos necesita, cuántos pueden fallar y qué tamaño útil tiene.
• Sé crear un RAID 5 con mdadm, comprobar su estado (/proc/mdstat, mdadm --detail) y hacer que se mantenga tras reiniciar (mdadm.conf y update-initramfs -u).
• Sé explicar por qué un RAID puede aparecer como md127 después de reiniciar.
• Sé crear volúmenes lógicos sobre el RAID (volumen físico, grupo de volúmenes y volúmenes lógicos) y explicar qué ventaja tiene LVM.
• Sé explicar por qué el volumen de la NAS se formatea en el servidor y los de la SAN no.

NAS con NFS

• Sé explicar qué hace el servidor NFS (exporta directorios) y qué hace el cliente (los monta), y qué puerto usa NFSv4.
• Sé exportar un directorio en /etc/exports a una red o a un equipo, en lectura y escritura o solo lectura, y aplicar los cambios (exportfs -ra, exportfs -v).
• Sé explicar cómo comprueba NFS los permisos (con el UID y el GID del cliente) y qué hacen root_squash, no_root_squash y all_squash.
• Sé resolver un Permission denied al escribir en un directorio NFS dando permisos en el servidor, y por qué no_root_squash es peligroso.
• Sé montar un directorio NFS en el cliente y servir su contenido desde un servidor web (permisos de www-data, <Directory> o alias).
• Sé investigar un access denied by server al montar (el cliente no está en la red o la IP de /etc/exports, falta exportfs -ra) y un montaje que se queda colgado.

SAN con iSCSI

• Identifico los elementos de iSCSI: target, LUN, portal, initiator e IQN.
• Sé configurar un target con tgt (backing-store, incominguser, initiator-address) y comprobar sus LUN.
• Sé descubrir los targets desde el cliente (iscsiadm -m discovery), configurar la autenticación CHAP en el nodo y conectarme (--login).
• Sé ver las sesiones activas y los discos que ha recibido el cliente (iscsiadm -m session, lsblk -S), y desconectarme (--logout) desmontando antes el disco.
• Sé hacer que el cliente vuelva a conectarse al target al arrancar (node.startup automatic).
• Sé investigar un authorization failure al conectarme (usuario o contraseña CHAP, falta authmethod CHAP, initiator-address) y por qué no aparece ningún disco (falta el --login o no existe el backing-store).

Montajes al arrancar con systemd

• Sé explicar qué es una unidad de montaje (.mount) y por qué su nombre tiene que coincidir con la ruta (systemd-escape).
• Sé escribir una unidad .mount para un directorio NFS y para un disco iSCSI, y activarla (daemon-reload, enable --now).
• Sé explicar por qué un disco iSCSI se monta por UUID y no por /dev/sdX.
• Sé explicar por qué un montaje por red tiene que esperar a la red (_netdev, After=network-online.target) y, en iSCSI, al servicio open-iscsi.
• Sé investigar por qué un disco no se monta al arrancar: cambia de nombre (se montaba por /dev/sdX), el Where= no coincide con el nombre de la unidad o, sin _netdev, el arranque se queda esperando.