Saltar al contenido

// Engineering Log

HTTPS y servidor web en la práctica: Parte 7 — Configuración de referencia de Nginx para un sitio HTTPS y lista de verificación

Publicado el 13.11.2026 · Autor:

// Ruta rápida

Este artículo pertenece al tema Seguridad y proteccion.

Las configuraciones de HTTPS están repartidas en una decena de temas: certificado y cadena, versiones de TLS, redirecciones, HSTS, cabeceras de seguridad, HTTP/2 y HTTP/3, caché, proxy hacia la aplicación, WebSocket, timeouts. En este artículo todo está recopilado en una única configuración que se puede usar como base para un sitio nuevo, y en una lista de comprobación con los comandos para verificar el resultado. La configuración está probada en Nginx 1.31 en Docker: nginx -t pasa, y todas las comprobaciones de la lista dan el resultado esperado.

Condiciones iniciales: sitio example.ru, certificado Let’s Encrypt emitido por certbot en /etc/letsencrypt/live/example.ru/, la aplicación escucha en 127.0.0.1:8080, los ficheros estáticos compilados con hash en el nombre están en /var/www/example.ru/public/assets/. Se necesita Nginx 1.25.1 o más reciente (directivas http2 on y http3 on); los paquetes oficiales de nginx.org vienen compilados con soporte para HTTP/3.

Estructura de archivos

/etc/nginx/
├── nginx.conf                  # del paquete, no lo cambiamos: incluye conf.d/*.conf
├── conf.d/
│   ├── 00-common.conf          # ajustes comunes: logs, compresión, upstream
│   ├── 10-default.conf         # servidor por defecto para nombres ajenos
│   └── example.ru.conf         # sitio
└── snippets/
    ├── ssl.conf                # parámetros TLS
    ├── security-headers.conf   # cabeceras de seguridad
    └── proxy.conf              # cabeceras para proxy hacia la aplicación

Los snippets se incluyen con la directiva include. Esto no solo reduce repeticiones, sino que evita la principal trampa de add_header, de la que se habla más abajo.

snippets/ssl.conf

nginx
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers off;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;

Perfil intermediate del generador de Mozilla: TLS 1.2 y 1.3; para TLS 1.2 solo conjuntos con forward secrecy y AEAD. ssl_session_tickets off — los tickets de sesión sin rotación regular de claves debilitan la forward secrecy; la reanudación de sesión funciona mediante la caché ssl_session_cache. Por qué se usan exactamente estos cifrados — en el artículo HTTP, HTTPS y TLS: Parte 5 — Versiones de TLS, conjuntos de cifrado, SNI, ALPN, ECH y mTLS.

snippets/security-headers.conf

nginx
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header X-Frame-Options "DENY" always;
add_header Permissions-Policy "camera=(), microphone=(), geolocation=()" always;
add_header Content-Security-Policy-Report-Only "default-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'" always;
add_header Alt-Svc 'h3=":443"; ma=86400' always;
  • HSTS por un año con subdominios. Si tienes subdominios sin HTTPS, quita includeSubDomains; en un sitio nuevo comienza con max-age=300 e incrementa gradualmente (HTTP, HTTPS y TLS: Parte 7 — Transición a HTTPS: redirecciones, HSTS, HTTPS-First y el encabezado Upgrade);
  • CSP en modo Report-Only: el navegador informa de violaciones en la consola pero no bloquea nada. Recolecta las violaciones, ajusta la política a tus scripts y contadores, y luego cambia la cabecera a Content-Security-Policy;
  • Alt-Svc informa al navegador sobre HTTP/3. Se pone aquí, y no en el bloque server, para no perderse dentro de un location con sus propios add_header;
  • always — las cabeceras se envían también en respuestas de error.

Trampa de add_header. Si en un location hay al menos un add_header, todos los add_header del nivel server dejan de aplicarse dentro de ese location. Por eso en cada location que tenga su propio add_header (más abajo — caché de estáticos) se incluye de nuevo el snippet.

snippets/proxy.conf

nginx
proxy_http_version 1.1;
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;
proxy_set_header X-Forwarded-Host  $host;

La aplicación tras el proxy recibe la dirección real del cliente y el esquema. Sin X-Forwarded-Proto la aplicación asume que funciona sobre HTTP y puede entrar en un bucle infinito de redirecciones a HTTPS.

conf.d/00-common.conf

nginx
server_tokens off;

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

log_format main_timing '$remote_addr - [$time_local] "$request" $status $body_bytes_sent '
                       '"$http_referer" "$http_user_agent" '
                       'rt=$request_time urt=$upstream_response_time us=$upstream_status '
                       'proto=$server_protocol tls=$ssl_protocol';

gzip on;
gzip_comp_level 5;
gzip_min_length 1024;
gzip_proxied any;
gzip_vary on;
gzip_types text/css application/javascript application/json image/svg+xml text/plain text/xml application/xml;

upstream app {
    server 127.0.0.1:8080;
    keepalive 32;
    keepalive_timeout 4s;
}
  • server_tokens off — no mostrar la versión de Nginx;
  • log con timings: rt — tiempo total de la petición, urt — tiempo de respuesta de la aplicación, us — código devuelto por la aplicación. Con eso se ve de inmediato dónde se pierde tiempo y quién devolvió el error (HTTPS y servidor web en la práctica: Parte 1 — Errores 502, 504, 499 y 413 en Nginx: causas y tiempos de espera);
  • gzip para tipos de texto; gzip_vary on añade Vary: Accept-Encoding para que los caches no confundan la versión comprimida y la no comprimida. Imágenes y fuentes como woff2 ya están comprimidas — por eso no están en la lista;
  • upstream con keepalive: las conexiones a la aplicación se reutilizan. keepalive_timeout 4s debe ser menor que el timeout de idle de la aplicación (en Node.js por defecto 5 s), de lo contrario habrá 502 poco frecuentes.

conf.d/10-default.conf

nginx
# Peticiones con nombre desconocido y por IP: cerrar la conexión sin revelar certificados
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    listen 443 ssl default_server;
    listen [::]:443 ssl default_server;
    ssl_reject_handshake on;
    return 444;
}

Responde a peticiones con nombres desconocidos y por dirección IP. Por HTTP Nginx cierra la conexión sin respuesta (código 444), por HTTPS rechaza el handshake sin revelar certificados (ssl_reject_handshake, Nginx 1.19.4+). Así se bloquean la suplantación de Host y el escaneo por IP (HTTP, HTTPS y TLS: Parte 12 — Ataques a nivel HTTP: smuggling, suplantación del Host, CSRF, XSS, SSRF y envenenamiento de caché).

conf.d/example.ru.conf

nginx
# HTTP: solo verificación de Let's Encrypt y redirección a HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name example.ru www.example.ru;

    location /.well-known/acme-challenge/ {
        root /var/www/letsencrypt;
    }
    location / {
        return 301 https://example.ru$request_uri;
    }
}

# www → dominio principal
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name www.example.ru;

    ssl_certificate     /etc/letsencrypt/live/example.ru/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.ru/privkey.pem;
    include snippets/ssl.conf;

    return 301 https://example.ru$request_uri;
}

# Sitio principal
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    listen 443 quic reuseport;
    listen [::]:443 quic reuseport;
    http2 on;
    http3 on;
    server_name example.ru;

    ssl_certificate     /etc/letsencrypt/live/example.ru/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.ru/privkey.pem;
    include snippets/ssl.conf;
    include snippets/security-headers.conf;

    access_log /var/log/nginx/example.ru.access.log main_timing;
    error_log  /var/log/nginx/example.ru.error.log warn;

    client_max_body_size 20m;
    root /var/www/example.ru/public;

    # Estáticos con hash en el nombre — cachear para siempre
    location /assets/ {
        include snippets/security-headers.conf;
        add_header Cache-Control "public, max-age=31536000, immutable" always;
        try_files $uri =404;
    }

    # Imágenes y otros estáticos sin hash
    location ~* \.(?:png|jpe?g|webp|avif|gif|svg|ico|woff2)$ {
        include snippets/security-headers.conf;
        add_header Cache-Control "public, max-age=86400" always;
        try_files $uri =404;
    }

    # WebSocket
    location /ws/ {
        proxy_pass http://127.0.0.1:8080;
        include snippets/proxy.conf;
        proxy_set_header Upgrade    $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_read_timeout 3600s;
    }

    # Aplicación
    location / {
        try_files $uri @app;
    }
    location @app {
        proxy_pass http://app;
        include snippets/proxy.conf;
        proxy_set_header Connection "";   # keepalive hacia la aplicación
        proxy_connect_timeout 5s;
        proxy_read_timeout    60s;
    }
}

Qué ocurre aquí:

  • puerto 80 — solo verificación de Let’s Encrypt y redirección permanente inmediata a la dirección final https://example.ru conservando la ruta;
  • www — bloque separado con redirección al dominio principal; el certificado debe incluir ambos nombres;
  • sitio principal — HTTP/2 por TCP e HTTP/3 por QUIC en el mismo puerto 443. reuseport para QUIC se especifica solo en un bloque server por dirección;
  • estáticos con hash — caché por un año con immutable; el resto de estáticos — por un día (HTTPS y servidor web en la práctica: Parte 4 — Almacenamiento en caché HTTP y CDN: Cache-Control, ETag, proxy_cache y purga de caché);
  • WebSocket — proxied directamente a la aplicación, con cabeceras Upgrade y Connection y un timeout de lectura largo;
  • todo lo demás — primero se busca el fichero en disco, si existe; si no, va a la aplicación vía upstream con keepalive.

Instalación

bash
sudo mkdir -p /etc/nginx/snippets /var/www/letsencrypt
# colocar los ficheros en sus lugares, luego:
sudo certbot certonly --webroot -w /var/www/letsencrypt \
  -d example.ru -d www.example.ru --deploy-hook 'systemctl reload nginx'
sudo nginx -t && sudo systemctl reload nginx
sudo ufw allow 80/tcp && sudo ufw allow 443/tcp && sudo ufw allow 443/udp

Mientras no haya certificado, los bloques en 443 no permitirán que Nginx arranque. Emite el certificado dejando temporalmente solo el bloque en el puerto 80, o usa certbot --nginx. UDP/443 es necesario para HTTP/3.

Lista de comprobación

Todos los comandos se ejecutan desde tu ordenador. El resultado esperado está indicado en el comentario.

bash
# 1. HTTP → HTTPS conservando la ruta
curl -s -o /dev/null -w '%{http_code} %{redirect_url}\n' 'http://example.ru/page?x=1'
# 301 https://example.ru/page?x=1

# 2. www → dominio principal
curl -s -o /dev/null -w '%{http_code} %{redirect_url}\n' https://www.example.ru/page
# 301 https://example.ru/page

# 3. nombre ajeno por HTTP y por HTTPS
curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: evil.example' http://192.0.2.10/
# 000 (conexión cerrada, código 444)
curl -sk -o /dev/null -w '%{http_code}\n' --resolve evil.example:443:192.0.2.10 https://evil.example/
# 000 (handshake rechazado)

# 4. cabeceras de seguridad, incluidas en respuestas de error
curl -sI https://example.ru/ | grep -iE '^(strict|x-content|referrer|x-frame|permissions|content-security|alt-svc)'
curl -sI https://example.ru/no-such-page | grep -ic '^strict-transport-security'
# 1

# 5. caché de estáticos
curl -sI https://example.ru/assets/app.1a2b.js | grep -i '^cache-control'
# cache-control: public, max-age=31536000, immutable

# 6. versiones de protocolo
curl -s -o /dev/null -w '%{http_version}\n' https://example.ru/            # 2
curl -s -o /dev/null -w '%{http_version}\n' --http3-only https://example.ru/   # 3, si curl está compilado con HTTP/3

# 7. TLS: cadena, versión, cifrado
openssl s_client -connect example.ru:443 -servername example.ru -brief </dev/null
# Protocol version: TLSv1.3 ... Verification: OK

# 8. comprobación completa de versiones y cifrados
testssl.sh example.ru

Adicionalmente:

  • SSL Labs (ssllabs.com/ssltest) — calificación final A o A+ (A+ requiere HSTS);
  • DevTools → Network, columna Protocol — h2, y tras volver a entrar h3;
  • el log example.ru.access.log — las peticiones tienen rt= y urt=, tls=TLSv1.3;
  • certbot renew --dry-run — renovación simulada funcionará, y --deploy-hook recargará Nginx.

Un ejemplo de proxy para una aplicación con WebSocket y un área de administración protegida (Vaultwarden): Secretos y zero trust: Parte 2 — Vaultwarden detrás de Caddy o Nginx y protección inicial.

Qué cambiar según tus necesidades

  • Sitio sin aplicación (estático): elimina el upstream, location /ws/ y @app; en location / deja try_files $uri $uri/ =404;, y para HTML añade Cache-Control: no-cache.
  • Subida de ficheros grandes: aumenta client_max_body_size en el location necesario, no para todo el sitio.
  • Peticiones largas (informes, exportaciones): bloque location separado con proxy_read_timeout aumentado.
  • Sitio detrás de CDN o balanceador: configura set_real_ip_from para sus direcciones, si no en los logs y en la aplicación aparecerán las IP del CDN en lugar de las de los visitantes; decide dónde poner HSTS y cabeceras — en el CDN o en el servidor, pero no en ambos lugares.
  • API para otros sitios: CORS — por lista de orígenes mediante map (HTTPS y servidor web en la práctica: Parte 3 — Qué es CORS: errores en la consola del navegador y configuración en Nginx).

// Tarea parecida

Si estás resolviendo algo parecido

Este artículo pertenece a uno de los temas principales de trabajo. Puedes seguir leyendo sobre el tema, ir a la página principal para entender a qué me dedico o abrir directamente los servicios.

Tema del artículo

Seguridad y proteccion

SSL, hardening, accesos, proteccion de servicios y configuraciones seguras.

Tareas frecuentes de este tema

  • Configurar SSL, certificados y conexiones seguras
  • Restringir accesos y cerrar puntos de entrada innecesarios
  • Reforzar la configuracion del servidor y los servicios

// Siguiente paso

Si necesitas ayuda con este tema y no solo otro artículo, es mejor ir directo a la página del servicio. La página principal y la selección de materiales quedan como rutas secundarias.

Abrir servicios

// Reviews

Reseñas relacionadas

apande

apande

Configuración de Nginx y OpenCart

07.09.2024 · ★ 5/5

Un comprador muy poderoso
kireevk

kireevk

Diagnóstico de Nginx Proxy Manager en un contenedor Docker y solución del problema

15.03.2024 · ★ 5/5

Comprador acostumbrado

// Contact

¿Necesitas ayuda?

Escríbeme y te ayudaré a resolver el problema

Respondo en un día laborable (03:00-13:00 GMT)

O deje su solicitud aquí:

Confirme que no es un bot.

Escribir y recibir una respuesta rápida