nginx

📘 Conceptos Fundamentales

  • Virtual Hosts
  • Sites available / JSON objects
  • Reverse Proxy
  • SSL / TLS
  • Buffer y caching
  • nginx.org
  • Arquitectura basada en eventos: asincronía y alta concurrencia
  • Worker Processes y Master Process
  • proxy
  • microservicios

⚙️ Instalación y Configuración

  • Docker
  • hub.docker.com/_/nginx
  • Linux
    • sudo apt install nginx
    • systemctl enable nginx
    • systemctl status nginx
  • Docker Compose
    • Mapear carpetas locales con -v
    • Volúmenes para logs y conf
    • Templates para configuración con variables de entorno
    • Copy vs Template para .conf y .env

🧭 Enrutamiento y Balanceo de Carga

🧩 Nginx Proxy Manager (NPM)

🌐 DNS y Subdominios

  • Duck DNS
  • Configurar subdominios en routers con loopback
  • Integración con VPN o túneles inversos
  • Configuración de registros A / CNAME
  • Redirección dinámica de IP pública a local
  • Uso de DNS dinámico para entornos domésticos o pequeños despliegues

🚀 Nginx con Node.js

  • Full NGINX Tutorial - Demo Project with Node.js, Docker - YouTube
  • Conceptos clave:
    • Single entry point (gateway)
    • Caché y buffer
    • Compresión, segmentación y chunks
    • Seguridad: headers, rate limit, protección DDOS
    • Redirect HTTP → HTTPS
    • Load balancing entre instancias Node.js
    • Control de carga en clúster Kubernetes
  • Replicas en Docker Compose:
    • Definición de services, ports, scale
    • Proxy a grupos de servidores (upstreams)
    • Comparación con apache

🧠 Configuración base (nginx.conf)

worker_processes auto;
events {
	worker_connections 1024;
}

http {
	include mime.types;
	sendfile on;
	server {
		listen 80;
		server_name localhost;
		location / {
			proxy_pass http://app_backend;
			proxy_set_header Host $host;
			proxy_set_header X-Real-IP $remote_addr;
		}
	}
	upstream app_backend {
		server app1:3000;
		server app2:3000;
	}
}

`

🔒 SSL / TLS

server {
	listen 443 ssl;
	server_name example.com;

	ssl_certificate /etc/ssl/certs/example.crt;
	ssl_certificate_key /etc/ssl/private/example.key;

	location / {
		proxy_pass http://localhost:3000;
	}
}

server {
	listen 80;
	server_name example.com;
	return 301 https://$host$request_uri;
}

🔐 SSL y TLS: Configuración y Certificados

  • SSL vs TLS: TLS es la evolución segura y moderna del protocolo SSL.
  • Certificados gestionados con openssl o con Nginx Proxy Manager / Let’s Encrypt.
  • Ejemplo de generación de certificados autofirmados:
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/ssl/private/example.key \
-out /etc/ssl/certs/example.crt

🔁 Comandos útiles

nginx -t                # Verifica la configuración
nginx -V            # Ver versión, módulos y parámetros de compilación
nginx -s reload         # Recarga sin reiniciar
nginx -s stop           # Detiene el servicio
ps aux | grep nginx     # Ver procesos activos
nginx -V                # Ver versión y módulos compilados

🧱 Configuración y Contextos

  • Directivas: parámetros que controlan comportamiento
  • Contextos:
    • main → configuración global
    • events → conexiones
    • http → servidores web
    • server → sitios virtuales
    • location → rutas específicas
  • apache vs nginx:
    • Apache procesa por hilo → más pesado
    • Nginx usa modelo asíncrono → mejor rendimiento con alta concurrencia
  • nginx-features:
    • Reverse Proxy, Load Balancer, API Gateway, Cache Layer
    • Static File Server
    • WebSocket y gRPC proxy
    • Integración con Grafana / Prometheus para métricas

🗂️ Archivos de Configuración y Virtual Hosts

  • /etc/nginx/nginx.conf → archivo principal.
  • /etc/nginx/conf.d/*.conf → configuraciones por servicio.
  • /etc/nginx/sites-available y /etc/nginx/sites-enabled → gestión de virtual hosts.

  • Definir dominios, subdominios y redirecciones.

🐳 Docker y Nginx

version: "3.9"
services:
	nginx:
		image: nginx:latest
		ports:
			- "80:80"
			- "443:443"
		volumes:
			- ./nginx.conf:/etc/nginx/nginx.conf
			- ./ssl:/etc/ssl
		depends_on:
			- app
	app:
		build: ./app
		expose:
			- "3000"

📡 Integraciones Modernas (2025)

  • API Gateway en arquitecturas de microservicios
    • Nginx como capa de entrada unificada
    • Control de tráfico, seguridad, logging y métricas
  • Edge Computing e IoT:
    • Nginx como proxy de borde
    • Filtrado y agregación de datos
    • Traefik y Nginx híbridos en entornos multi-cloud
  • Observabilidad:
    • Integración con Grafana, Prometheus, ELK Stack
  • Algoritmos de balanceo modernos:
    • Round Robin
    • Least Connections
    • IP Hash
    • Random with two choices
    • Weight-based balancing (priorización)
  • Seguridad avanzada:
    • WAF (Web Application Firewall)
    • Rate Limiting y DDoS Protection
    • CSP, HSTS, y headers seguros

      🧰 Servidor Web como Servicio

  • Concepto de Nginx como servicio gestionado (PaaS)
  • Despliegues automatizados con herramientas como Kubernetes o Docker Swarm
  • Integración con pipelines CI/CD (e.g., DevOps)

📚 Recursos

nginx (expansión avanzada 2025)

🔌 Módulos y Extensibilidad

  • Arquitectura modular
    • NGINX permite cargar módulos estáticos o dinámicos (desde v1.9.11)
    • load_module modules/ngx_http_js_module.so;
  • Módulos populares
    • ngx_http_geoip_module: geolocalización
    • ngx_http_realip_module: IP real del cliente detrás de proxy
    • ngx_stream_module: soporte TCP/UDP
    • ngx_http_js_module (ex njs): ejecutar JS dentro de NGINX
    • ngx_http_lua_module (OpenResty): scripting avanzado en Lua
  • OpenResty
    • Framework sobre NGINX que permite lógica compleja (autenticación, rate limiting, APIs)
    • Usado para sistemas de alto rendimiento o edge computing

🌐 Protocolos Modernos y Comunicación

  • HTTP/2 y HTTP/3 (QUIC)
    • Soporte nativo desde versiones recientes
    • Configuración:
		listen 443 ssl http2;
		```

		
```nginx
		listen 443 ssl http3;
		add_header Alt-Svc 'h3=":443"';
		```

	- Multiplexación, compresión de cabeceras y menor latencia
- **WebSockets**
	- Proxy transparente con soporte full-duplex  
		
```nginx
		proxy_set_header Upgrade $http_upgrade;
		proxy_set_header Connection "upgrade";
		```

- **gRPC**
	- `grpc_pass` para backend de microservicios
	- Integración con API Gateway modernos y entornos [Kubernetes](/virtualizacion/kubernetes/)

---

## 🧠 Caché y Optimización
- **Proxy Cache**
	- `proxy_cache_path /data/nginx/cache keys_zone=my_cache:10m;`
	- Control de caducidad: `proxy_cache_valid 200 302 10m;`
- **FastCGI Cache**
	- Para backends PHP o Python
	- `fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=phpcache:10m inactive=60m;`
- **Compresión y transporte**
	- `gzip on; gzip_types text/plain text/css application/json;`
	- `sendfile on; tcp_nopush on;`
- **Caché avanzada**
	- `proxy_cache_use_stale` para servir contenido viejo si el backend falla
	- Purga con herramientas externas (`nginx cache_purge` module)

---

## 🛡️ Seguridad Avanzada
- **Cabeceras de Seguridad**
	- `add_header X-Frame-Options "SAMEORIGIN";`
	- `add_header X-Content-Type-Options "nosniff";`
	- `add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";`
- **Rate Limiting**
	- `limit_req_zone $binary_remote_addr zone=limite:10m rate=10r/s;`
	- `limit_req zone=limite burst=20 nodelay;`
- **Autenticación**
	- HTTP Basic: `auth_basic "Restricted";`
	- Integración con OAuth2 / JWT mediante módulos externos
- **WAF (Web Application Firewall)**
	- Integración con **ModSecurity** o **NAXSI**
	- Inspección de patrones, SQLi/XSS, control por IP
- **SSL/TLS avanzado**
	- Curvas elípticas y protocolos seguros:
		
```nginx
		ssl_protocols TLSv1.2 TLSv1.3;
		ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM';
		ssl_prefer_server_ciphers on;
		ssl_session_cache shared:SSL:10m;
		```

	- Certificados automáticos con **Let's Encrypt** o **Certbot**
	- Soporte de OCSP Stapling y HSTS

---

## ⚙️ Rendimiento y Tuning de Sistema
- **Parámetros clave**
	- `worker_processes auto;`
	- `worker_connections 4096;`
	- `multi_accept on;`
	- `keepalive_timeout 65;`
- **Tuning SO**
	- Ajustar `ulimit -n` (límite de archivos abiertos)
	- `net.core.somaxconn` para backlog de conexiones
	- Uso de `epoll` y CPU affinity:

```nginx
worker_cpu_affinity auto;
  • Observabilidad
    • Logs JSON o extendidos para análisis con Grafana / Prometheus
    • Métricas expuestas con stub_status o ngx_http_status_module
    • Integración con herramientas APM (Elastic APM, Datadog)

🧩 Despliegue, CI/CD y Alta Disponibilidad

  • Zero-Downtime Reload
    • nginx -t && nginx -s reload
    • Mantiene conexiones sin cortar sesiones
  • Blue-Green / Canary Deployments
    • Definir pools de upstream alternativos
    • split_clients para enrutar tráfico por porcentaje
  • Rollback
    • Versionar archivos de configuración
    • Validar sintaxis en pipelines de GitHub Actions o Jenkins
  • Alta Disponibilidad
    • Keepalived o HAProxy para failover
    • Replicación de configuraciones con etcd o consul

☁️ Edge, IoT y Serverless

  • NGINX en el Edge
    • Integrado con Cloudflare Workers y AWS Lambda@Edge
    • Procesamiento local en gateways IoT (menor latencia)
  • NGINX + Serverless
    • Front proxy hacia funciones (FaaS) como OpenFaaS o Knative
  • Multi-cloud
    • Balanceo global con DNS dinámico y health checks distribuidos

💼 NGINX Plus vs Open Source

  • NGINX Open Source
    • Código abierto, gran comunidad, extensible
  • NGINX Plus (comercial)
    • Dashboard con métricas en tiempo real
    • API REST de configuración dinámica
    • Health checks activos, session persistence, JWT nativo
    • Soporte profesional y actualizaciones priorizadas
  • NGINX Controller: interfaz para gestionar múltiples instancias NGINX Plus

🔍 Buenas Prácticas de Producción

  • Validar configuración antes de desplegar: nginx -t
  • Usar include modular para sitios y entornos
  • Versionar todos los .conf en Git
  • Separar logs por entorno (access_dev.log, access_prod.log)
  • Probar redirecciones y headers con:
    • curl -I -L https://tusitio.com
  • Automatizar con Ansible / Terraform

📚 Referencias y Recursos

📌 Temas Adicionales Avanzados

🧬 Desarrollo de Módulos Personalizados

  • Escritura de módulos en C para NGINX (handler, filter, load-balancer) usando ngx_command_t, ngx_module_t, etc. :contentReference[oaicite:1]{index=1}
  • Uso de memoria compartida (ngx_shared_memory_add, ngx_slab_alloc) para almacenamiento entre procesos worker. :contentReference[oaicite:2]{index=2}
  • Sub-requests internos: emitir varias peticiones desde un módulo a backends internos y combinar los resultados. :contentReference[oaicite:3]{index=3}
  • Carga dinámica de módulos (.so) con la directiva load_module modules/…; (soportado en NGINX Plus y Open Source con configuración adecuada). :contentReference[oaicite:4]{index=4}

🔄 Streaming y Protocolos de Nivel Bajo

  • Proxy de TCP/UDP usando el contexto stream { … }, habilitando NGINX como proxy de nivel 4.
  • Soporte para streaming de medios (HLS, DASH) mediante chunked_transfer_encoding, configuración proxy_buffering, proxy_max_temp_file_size. :contentReference[oaicite:5]{index=5}
  • Técnicas para reescritura compleja de URLs, variables de NGINX ($http_user_agent, $scheme, etc.), y reglas rewrite/return avanzadas. :contentReference[oaicite:6]{index=6}

🛠️ Control de Acceso y Autenticación Avanzada

  • Validación de tokens JWT, integración con SSO, uso de módulos externos para autenticación mediante OAuth2/OpenID Connect. :contentReference[oaicite:7]{index=7}
  • Listas de control de acceso por IP, geo-IP, cabeceras específicas del cliente, bloqueos dinámicos (fail2ban, etc).
  • Cobertura de reglas WAF (Web Application Firewall) integradas o externas (por ejemplo ModSecurity). :contentReference[oaicite:9]{index=9}

📦 Clúster, Estado y Persistencia

  • Persistencia de sesión (session stickiness) en balanceo de carga, replicación de estado entre nodos, sincronización de configuración. :contentReference[oaicite:10]{index=10}
  • Uso de etcd/consul para compartir configuración entre múltiples instancias NGINX en un entorno de producción distribuido.
  • Monitoreo de estado de nodos upstream, health checks activas vs pasivas, con failover automático.

🎯 Técnicas de Observabilidad y Telemetría

  • Exposición de métricas internas mediante stub_status, ngx_http_status_module, integración con Prometheus/Grafana.
  • Logs estructurados (JSON) para ingestión en sistemas de logging centralizados, trazabilidad de peticiones y análisis de latencia.
  • Uso de APM (Application Performance Monitoring) para identificar cuellos de botella en el stack proxy → backend.

🧪 Investigación y Futuro

  • Investigaciones recientes muestran políticas de limpieza de caché mejoradas mediante aprendizaje por refuerzo integradas en NGINX. :contentReference[oaicite:13]{index=13}
  • Ataques emergentes como request smuggling y discrepancias de procesamiento entre proxies — importante para arquitecturas compuestas. :contentReference[oaicite:14]{index=14}

✅ Resumen Final

Estos temas complementan lo que ya tienes: desarrollo a nivel de módulo, protocolos de bajo nivel, autenticación avanzada, clústeres distribuidos, observabilidad y las tendencias más recientes de investigación.

🧩 Plantillas y Configuración Avanzada de nginx

🧬 Desarrollo de Módulos Personalizados

Ejemplo: Módulo C básico

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

static ngx_int_t ngx_http_hello_handler(ngx_http_request_t *r) {
	r->headers_out.status = NGX_HTTP_OK;
	r->headers_out.content_type.len = sizeof("text/plain") - 1;
	r->headers_out.content_type.data = (u_char *)"text/plain";
	ngx_http_send_header(r);
	ngx_buf_t *b = ngx_create_temp_buf(r->pool, sizeof("Hello NGINX\n"));
	ngx_memcpy(b->pos, "Hello NGINX\n", sizeof("Hello NGINX\n"));
	b->last = b->pos + sizeof("Hello NGINX\n");
	b->last_buf = 1;
	ngx_chain_t out = { b, NULL };
	return ngx_http_output_filter(r, &out);
}

static ngx_http_module_t ngx_http_hello_module_ctx = {
	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
};

ngx_module_t ngx_http_hello_module = {
	NGX_MODULE_V1,
	&ngx_http_hello_module_ctx,
	NULL,
	NGX_HTTP_MODULE,
	NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	NGX_MODULE_V1_PADDING
};

`

Compilación y carga

./configure --add-module=/path/to/hello_module
make && sudo make install

O dinámicamente:

load_module modules/ngx_http_hello_module.so;

🔄 Proxy TCP/UDP y Streaming (stream {})

Permite a NGINX actuar como proxy de nivel 4 (TCP/UDP).

stream {
	upstream backend_tcp {
		server db1.example.com:3306;
		server db2.example.com:3306;
	}

	server {
		listen 3306;
		proxy_pass backend_tcp;
		proxy_timeout 10s;
		proxy_connect_timeout 3s;
	}
}

🔐 Autenticación JWT / OAuth2

Validación JWT (con módulo ngx_http_auth_jwt_module)

http {
	server {
		listen 443 ssl;
		ssl_certificate /etc/ssl/certs/server.crt;
		ssl_certificate_key /etc/ssl/private/server.key;

		location /api/ {
			auth_jwt "API Restricted";
			auth_jwt_key_file /etc/nginx/keys/jwt_public.pem;
			proxy_pass http://backend_api;
		}
	}
}

Autenticación básica con archivo de usuarios

sudo apt install apache2-utils
htpasswd -c /etc/nginx/.htpasswd admin

location /secure/ {
	auth_basic "Restricted Zone";
	auth_basic_user_file /etc/nginx/.htpasswd;
	proxy_pass http://backend_secure;
}

📊 Observabilidad y Métricas

Módulo stub_status

server {
	listen 8080;
	location /status {
		stub_status;
		allow 127.0.0.1;
		deny all;
	}
}

Salidas típicas:

Active connections: 15
accepts handled requests
 1024 1024 2048
Reading: 1 Writing: 2 Waiting: 12

Exportación Prometheus (módulo nginx-prometheus-exporter)

docker run -d -p 9113:9113 \
	nginx/nginx-prometheus-exporter:latest \
	--nginx.scrape-uri http://localhost:8080/status

🧠 Reescrituras y Variables Avanzadas

Reescritura condicional y regex

server {
	listen 80;
	server_name example.com;

	if ($http_user_agent ~* "(curl|wget)") {
		return 403;
	}

	location ~ ^/v([0-9]+)/api/(.*)$ {
		rewrite ^/v([0-9]+)/api/(.*)$ /api/v$1/$2 break;
		proxy_pass http://backend_api;
	}
}

Headers y seguridad

add_header X-Frame-Options SAMEORIGIN;
add_header X-Content-Type-Options nosniff;
add_header Content-Security-Policy "default-src 'self'";

⚙️ SSL / TLS Configuración Completa

Generar certificado autofirmado

openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/ssl/private/nginx-selfsigned.key \
-out /etc/ssl/certs/nginx-selfsigned.crt

Configuración HTTPS

server {
	listen 443 ssl http2;
	server_name mydomain.com;

	ssl_certificate /etc/ssl/certs/nginx-selfsigned.crt;
	ssl_certificate_key /etc/ssl/private/nginx-selfsigned.key;
	ssl_protocols TLSv1.2 TLSv1.3;
	ssl_ciphers HIGH:!aNULL:!MD5;
	ssl_prefer_server_ciphers on;

	location / {
		proxy_pass http://127.0.0.1:8080;
	}
}

Redirección HTTP → HTTPS

server {
	listen 80;
	server_name mydomain.com;
	return 301 https://$host$request_uri;
}

⚡ Balanceo de carga con “health checks”

upstream backend_cluster {
	server app1.example.com weight=3 max_fails=2 fail_timeout=10s;
	server app2.example.com;
	server app3.example.com backup;
}

server {
	listen 80;
	location / {
		proxy_pass http://backend_cluster;
		proxy_next_upstream error timeout invalid_header http_500;
	}
}

🧪 Integración con Kubernetes / Docker Swarm

upstream app_cluster {
	server app1:3000;
	server app2:3000;
}

server {
	listen 80;
	location / {
		proxy_pass http://app_cluster;
	}
}
  • Montar configmap:
kubectl create configmap nginx-config --from-file=nginx.conf
kubectl apply -f nginx-deployment.yaml

🔭 Logs y formato JSON

log_format json_combined escape=json
	'{'
	'"time":"$time_iso8601",'
	'"remote_addr":"$remote_addr",'
	'"method":"$request_method",'
	'"uri":"$request_uri",'
	'"status":$status,'
	'"bytes_sent":$body_bytes_sent,'
	'"request_time":$request_time'
	'}';

access_log /var/log/nginx/access.log json_combined;

🚀 Optimización y Buenas Prácticas 2025

  • HTTP/3 (QUIC): habilitar con listen 443 quic; y ssl_reuse.
  • Brotli compression (ngx_brotli): mejora ~20–30% frente a gzip.
  • OCSP stapling: reduce handshake SSL.
  • Caching adaptativo: integrar con Redis o Varnish para grandes cargas.
  • Reverse proxy inteligente: detección de latencia dinámica para elegir upstream.
  • Edge Computing con NGINX Unit: ejecución de código (Python, Go, Node.js) embebido.

📘 Referencias

NGINX (actualizado 2025)

🧩 Arquitectura moderna de NGINX

  • NGINX OSS vs NGINX Plus
    • OSS: libre, ideal para proxy reverso, balanceo básico y cacheo.
    • Plus: métricas avanzadas, dashboards, health checks activos, JWT auth, API REST.
  • Procesamiento asíncrono y basado en eventos → cada worker puede manejar miles de conexiones concurrentes.
  • Pipeline de peticiones
    • Connection → Request → Phase Handlers → Response.
    • Contextos: main, events, http, server, location.

🔐 SSL/TLS y seguridad avanzada

Configuración básica SSL

server {
	listen 443 ssl http2;
	server_name example.com;

	ssl_certificate /etc/nginx/ssl/example.crt;
	ssl_certificate_key /etc/nginx/ssl/example.key;

	ssl_protocols TLSv1.2 TLSv1.3;
	ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256';
	ssl_prefer_server_ciphers on;
	add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
}

`

Comandos útiles

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/nginx/ssl/self.key -out /etc/nginx/ssl/self.crt
nginx -t   # validar configuración
nginx -s reload   # recargar configuración sin reiniciar

Seguridad moderna

  • TLS 1.3 habilitado por defecto (mejor handshake y menos latencia).
  • OCSP Stapling y Session Tickets para acelerar validaciones.
  • Let’s Encrypt + certbot o nginx-proxy-manager para certificados automáticos.
  • CSP, HSTS y seguridad de cabeceras
  add_header X-Frame-Options "SAMEORIGIN";
  add_header X-Content-Type-Options "nosniff";
  add_header Content-Security-Policy "default-src 'self';";
  • Protección DDoS básica
  limit_req_zone $binary_remote_addr zone=req_limit:10m rate=10r/s;
  location / {
  	limit_req zone=req_limit burst=20;
  }

⚙️ Rendimiento y optimización

  • HTTP/3 + QUIC (requiere listen 443 quic reuseport;)

    • mejora latencia en móviles y redes inestables.

  • Compresión y cacheo

  gzip on;
  gzip_types text/plain text/css application/json;
  proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m;
  proxy_cache my_cache;

  • Conexiones persistentes y multiplexación HTTP/2

    • keepalive_timeout 65;
    • http2_push_preload on;

🧠 Balanceo y alta disponibilidad

  • Upstreams dinámicos
  upstream backend {
  	least_conn;
  	server app1:3000;
  	server app2:3000;
  }
  server {
  	location /api/ {
  		proxy_pass http://backend;
  	}
  }
  • Métodos: round_robin, least_conn, ip_hash, hash key consistent;
  • Health checks activos (NGINX Plus) y pasivos (max_fails, fail_timeout).
  • Integración con Consul, etcd, o Kubernetes Service Discovery.
  • Zero downtime reload → nginx -s reload.

📊 Observabilidad y métricas

  • Logs estructurados JSON
  log_format json_combined escape=json '{ "time": "$time_iso8601", "remote_addr": "$remote_addr", "status": "$status", "request": "$request" }';
  access_log /var/log/nginx/access.log json_combined;

  • Exporters Prometheus/Grafana

  • Tracing distribuido

    • opentracing module → Jaeger o OpenTelemetry.

🐳 NGINX en entornos Docker y Kubernetes

  • Usar COPY nginx.conf /etc/nginx/nginx.conf o templates con variables de entorno (envsubst).
  • Configuración dinámica con configMap en K8s:
  kind: ConfigMap
  apiVersion: v1
  metadata:
    name: nginx-config
  data:
    default.conf: |
      server {
        listen 80;
        location / {
          proxy_pass http://app-svc:8080;
        }
      }

  • NGINX Ingress Controller

    • Controla el tráfico de entrada en clústeres Kubernetes.
    • Añade reglas TLS, rutas por dominio y rate limiting global.

  • Integración con Traefik o Istio como gateway alternativos.

🔁 Automatización y CI/CD

  • Despliegues con Ansible o Terraform.

  • Integración con pipelines CI/CD:

    • validación nginx -t antes del deploy.
    • reload automatizado vía webhook.
  • Versionado de configuraciones (GitOps con ArgoCD o Flux).

🧰 Utilidades CLI

nginx -v           # versión
nginx -V           # módulos compilados
ps aux | grep nginx  # procesos activos
sudo systemctl restart nginx
sudo nginx -T      # mostrar toda la config efectiva

🌐 Extensiones y módulos destacados

  • ModSecurity WAF (Web Application Firewall)
  • ngx_brotli → compresión más eficiente que gzip
  • ngx_stream_core_module → balanceo TCP/UDP
  • ngx_http_stub_status_module → endpoint /status
  • ngx_cache_purge → invalidación manual de caché

📦 Casos de uso modernos (2025)

  • Proxy inverso para APIs, gRPC y WebSockets.
  • Edge caching para contenido estático global.
  • Gateway de microservicios híbrido (con JWT y rate limits).
  • Servir modelos IA o APIs de inferencia via HTTP/3.
  • Frontend edge delivery (React/Vue/Svelte) en CDNs autoservidos.

🔗 Recursos

🔐 Configuraciones avanzadas SSL/TLS en NGINX (2025)

Seguridad de capa de transporte moderna, automatización de certificados, y despliegues productivos.

🧾 1. Configuración multi-dominio (SAN / SNI)

Permite servir varios dominios desde el mismo servidor o IP mediante Server Name Indication (SNI).

# default_server como fallback
server {
	listen 443 ssl http2 default_server;
	server_name example.com www.example.com;

	ssl_certificate     /etc/ssl/example.crt;
	ssl_certificate_key /etc/ssl/example.key;
}

server {
	listen 443 ssl http2;
	server_name api.example.net;

	ssl_certificate     /etc/ssl/api.crt;
	ssl_certificate_key /etc/ssl/api.key;
}

`

Notas:

  • Cada server_name puede usar un certificado distinto.
  • Let’s Encrypt (Certbot o acme.sh) puede automatizar certificados SNI múltiples.

🧮 2. OCSP Stapling (validación optimizada)

Evita que el cliente contacte a la CA en cada conexión, mejorando la latencia SSL.

ssl_stapling on;
ssl_stapling_verify on;
ssl_trusted_certificate /etc/ssl/ca-chain.pem;
resolver 1.1.1.1 8.8.8.8 valid=300s;
resolver_timeout 5s;

Ventaja: reduce el tiempo del handshake TLS y evita bloqueos por CA lentas.

🧩 3. Certificados Let’s Encrypt automáticos

Automatización de certificados gratis con Certbot o nginx-proxy-manager.

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com

Renovación automática:

sudo systemctl enable certbot.timer
sudo certbot renew --dry-run

En Docker Compose

services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/letsencrypt

🧱 4. Redirección HTTPS + HSTS

Redirige automáticamente tráfico HTTP a HTTPS y aplica seguridad de transporte estricta.

server {
	listen 80;
	server_name example.com www.example.com;
	return 301 https://$host$request_uri;
}

server {
	listen 443 ssl http2;
	server_name example.com www.example.com;

	ssl_certificate /etc/ssl/example.crt;
	ssl_certificate_key /etc/ssl/example.key;
	add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
}

🧍‍♂️ 5. Autenticación mutua (mTLS)

Para APIs internas, IoT o servicios sensibles. El cliente también presenta su certificado.

server {
	listen 443 ssl;
	server_name internal.example.com;

	ssl_certificate     /etc/ssl/server.crt;
	ssl_certificate_key /etc/ssl/server.key;
	ssl_client_certificate /etc/ssl/ca-clients.pem;
	ssl_verify_client on;

	location / {
		if ($ssl_client_verify != SUCCESS) {
			return 403;
		}
		proxy_pass http://backend_internal;
	}
}

Flujo mTLS:

  1. El cliente se autentica con su propio certificado firmado.
  2. NGINX valida con ssl_client_certificate.
  3. Se puede inspeccionar $ssl_client_s_dn para logs o control de acceso.

⚡ 6. HTTP/3 + QUIC (nuevo estándar)

NGINX 1.25+ y OpenSSL 3+ incluyen soporte nativo. Mejora latencia y resiliencia.

server {
	listen 443 ssl http2;
	listen 443 quic reuseport;
	server_name example.com;

	ssl_certificate /etc/ssl/example.crt;
	ssl_certificate_key /etc/ssl/example.key;

	add_header Alt-Svc 'h3=":443"; ma=86400';
	add_header QUIC-Status $quic;
}

Verificación:

curl -I --http3 https://example.com

🧰 7. TLS tuning (rendimiento y seguridad)

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
ssl_session_timeout 1d;
ssl_session_tickets off;

Buenas prácticas 2025:

  • Solo TLS 1.2 y 1.3.
  • Desactivar session_tickets si no se rotan periódicamente.
  • Configurar ssl_buffer_size 4k; para optimizar latencia.

🔍 8. Monitorización SSL en producción

Logs detallados

log_format ssl '$remote_addr - $ssl_protocol/$ssl_cipher $status $bytes_sent';
access_log /var/log/nginx/ssl_access.log ssl;

Métricas Prometheus (con NGINX Plus o exporter)

  • nginx_ssl_handshakes_total
  • nginx_ssl_session_reuses_total
  • nginx_ssl_connections_active

📘 9. Certificados wildcard y multi-site

Wildcard: *.example.com (útil para subdominios múltiples)

sudo certbot certonly --manual --preferred-challenges=dns -d "*.example.com" -d example.com

En NGINX:

server {
	listen 443 ssl;
	server_name *.example.com;

	ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
	ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
}

🧩 10. Integración con NGINX Proxy Manager

  • Interfaz web para crear hosts, redirecciones y certificados SSL automáticamente.
  • Manejador visual de reglas, listas blancas y redirección HTTPS forzada.
  • Certificados Let’s Encrypt renovados automáticamente.

🔗 Recursos útiles


---

¿Quieres que te prepare una **nota separada de “nginx-ssl-tls-cheatsheet”** con solo comandos, configuraciones y buenas prácticas resumidas para producción (sin explicaciones)?  
Sería ideal para consultas rápidas o automatización CI/CD.

🧠 Glosario NGINX (2025)

Diccionario técnico con los conceptos y tecnologías relacionados con NGINX, proxies, microservicios y seguridad SSL/TLS.
Ideal como referencia cruzada con notas como proxy, nginx-features, microservicios, Docker, Kubernetes, Traefik y security.

🔩 Fundamentos de NGINX

  • NGINX → Servidor web, proxy inverso, balanceador de carga y cacheador de alto rendimiento.
    Diseñado para manejar concurrencia masiva mediante arquitectura event-driven y non-blocking I/O.

  • Worker processes → Procesos que manejan las conexiones y peticiones. Su número determina el paralelismo.

  • Master process → Proceso principal que gestiona la configuración y lanza los workers.

  • Directives → Instrucciones individuales en los archivos de configuración (nginx.conf), que definen comportamiento.

  • Contextos (main, http, server, location) → Ámbitos jerárquicos donde se aplican las directivas.

  • Entrypoint → Punto de entrada de una aplicación o servicio. En NGINX, es una combinación de server + location.

🧱 Arquitectura y configuración

  • Virtual Hosts → Configuraciones de múltiples sitios web en un solo servidor.
    Se crean en bloques server definidos por server_name.

  • Sites-available / sites-enabled → Convención usada en distribuciones Linux (Debian, Ubuntu) para organizar hosts activos.

  • Reverse Proxy → Intermediario que recibe peticiones del cliente y las reenvía al backend.
    Ejemplo: proxy_pass http://backend_service;

  • Forward Proxy → Proxy usado por clientes para acceder a recursos externos (poco común en NGINX).

  • Upstream → Grupo de servidores backend definidos para balanceo de carga.

  upstream api_servers {
    server api1:3000;
    server api2:3000;
  }

`

  • Location blocks → Secciones que determinan el enrutamiento según patrones de URL o expresiones regulares.

  • Headers personalizados → Variables como $host, $remote_addr, $request_uri se pueden enviar a los backends con:

  proxy_set_header Host $host;
  proxy_set_header X-Real-IP $remote_addr;
  • Buffer → Almacenamiento temporal de peticiones y respuestas. Controla rendimiento y latencia.

⚙️ Comandos esenciales

  • nginx -t → Verifica sintaxis de configuración.
  • nginx -s reload → Recarga configuración sin reiniciar el proceso.
  • nginx -s stop → Detiene el servicio.
  • nginx -V → Muestra versión y módulos compilados.
  • ps aux | grep nginx → Verifica procesos activos.

🧭 Enrutamiento y balanceo de carga

  • Load Balancer (Balanceador de carga) → Distribuye tráfico entre varios backends. Métodos comunes:

    • Round Robin: distribución uniforme.
    • Least Connections: elige el servidor menos ocupado.
    • IP Hash: mantiene afinidad de sesión según IP.
    • Hash basado en cookie o header: útil para servicios con estado.

  • Router → Reglas que determinan a qué backend se dirige cada petición (por URL, cabecera o método HTTP).

  • Regex Matching → Uso de expresiones regulares en location ~ o if para patrones de enrutamiento complejos.

  • Health checks → Verificación de disponibilidad de backends en configuraciones upstream.

🧰 Docker, DevOps y despliegue

  • Imagen oficial de NGINX → Disponible en Docker Hub o Docker.

  • Volúmenes (-v) → Mapear directorios locales al contenedor (para logs o configuración):

  docker run -d -p 80:80 -v ./nginx.conf:/etc/nginx/nginx.conf nginx

  • Templates y envfiles → Plantillas dinámicas para generar configuraciones basadas en variables de entorno.

  • Nginx Proxy Manager (NPM) → Interfaz web para crear hosts, certificados SSL, y redirecciones visualmente. Permite automatizar:

    • Redirecciones HTTP/HTTPS.
    • Certificados Let’s Encrypt.
    • Whitelist de IPs.
    • Redirección entre contenedores (DNS interno).

  • Docker Swarm / Kubernetes → Orquestadores que gestionan múltiples instancias de NGINX en clústeres distribuidos.

🔒 Seguridad, SSL y TLS

  • SSL (Secure Sockets Layer) → Protocolo original para cifrado en red.

  • TLS (Transport Layer Security) → Evolución moderna de SSL, usada actualmente (TLS 1.2, TLS 1.3).

  • Certificados → Archivos .crt (público) y .key (privado). Se generan con openssl o Let’s Encrypt.

  • OCSP Stapling → Mecanismo que acelera la validación de certificados al incluir información de estado en el handshake.

  • SNI (Server Name Indication) → Permite a NGINX servir múltiples dominios SSL en la misma IP.

  • HSTS (HTTP Strict Transport Security) → Política que fuerza al cliente a usar HTTPS.

  add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

  • mTLS (Mutual TLS) → Autenticación mutua cliente-servidor mediante certificados. Ideal para APIs internas o IoT.

  • Certbot → Herramienta de Let’s Encrypt para emitir y renovar certificados automáticamente.

  • Wildcard Certificate → Certificado que cubre todos los subdominios de un dominio: *.example.com.

  • OCSP/CRL → Mecanismos de revocación de certificados.

  • HTTP/2 y HTTP/3 → Protocolos modernos que mejoran rendimiento y seguridad sobre TLS.

  • QUIC → Protocolo basado en UDP que permite conexiones más rápidas y resilientes (usado en HTTP/3).

🧮 Performance y optimización

  • Cache → Almacenamiento de respuestas para reducir carga en backend (proxy_cache, fastcgi_cache).

  • Compression (gzip, brotli) → Compresión de respuestas HTTP para reducir tamaño de transferencia.

  • Chunked Encoding → Segmentación de respuestas en fragmentos para streaming o contenido dinámico.

  • Keep-Alive Connections → Mantiene conexiones abiertas para reducir latencia entre cliente y servidor.

  • Session Resumption / Tickets → Reutilización de sesiones TLS para acelerar reconexiones.

  • HTTP/3 → Reduce latencia y mejora confiabilidad en redes inestables (basado en QUIC/UDP).

🌐 DNS, dominios y redes

  • DNS A record → Asocia un dominio a una IP.
  • Loopback Router → Permite redirigir tráfico local (localhost → dominio simulado).
  • DuckDNS → Servicio gratuito de DNS dinámico (útil para entornos domésticos o pruebas).
  • Proxy DNS interno → Resolución de nombres entre contenedores dentro de la red Docker.

🧠 Integraciones y extensiones

  • API Gateway → Puerta de entrada unificada a microservicios. Controla autenticación, rate-limiting y logs.
  • Grafana / Prometheus → Herramientas de monitorización. Exponen métricas de NGINX (con nginx-exporter o nginx-plus).
  • Traefik → Alternativa moderna a NGINX Proxy Manager, nativa para Docker/Kubernetes.
  • Service Workers → Scripts del lado del cliente que controlan caching, routing y offline-first en apps web.

📊 Logs y monitorización

  • Access Logs / Error Logs → Archivos donde se registran peticiones y errores.
  access_log /var/log/nginx/access.log;
  error_log /var/log/nginx/error.log warn;
  • Formato de log personalizado
  log_format main '$remote_addr - $ssl_protocol/$ssl_cipher $status $bytes_sent';

  • Métricas útiles

    • nginx_ssl_handshakes_total
    • nginx_ssl_session_reuses_total
    • nginx_http_requests_total
    • nginx_connections_active

📚 Recursos recomendados

🧾 nginx-cheatsheet-commands

Referencia rápida de comandos, bloques de configuración y directivas NGINX.
Relacionado con nginx, proxy, SSL, Docker, DevOps y microservicios.

🧩 Comandos básicos

nginx -t                # Verifica sintaxis
nginx -s reload         # Recarga configuración
nginx -s stop           # Detiene el servicio
nginx -s quit           # Detiene de forma segura
nginx -V                # Ver versión y módulos
ps aux | grep nginx     # Procesos activos
systemctl status nginx  # Estado del servicio
systemctl restart nginx # Reinicia nginx

`

🧱 Estructura general de configuración

worker_processes auto;

events {
	worker_connections 1024;
}

http {
	include mime.types;
	default_type application/octet-stream;
	sendfile on;

	server {
		listen 80;
		server_name example.com www.example.com;

		location / {
			root /usr/share/nginx/html;
			index index.html;
		}
	}
}

🌐 Reverse Proxy

server {
	listen 80;
	server_name api.example.com;

	location / {
		proxy_pass http://backend:3000;
		proxy_set_header Host $host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
}

⚖️ Load Balancing

upstream backend_cluster {
	server backend1:3000;
	server backend2:3000;
	# server backend3:3000 backup;
}

server {
	listen 80;
	server_name app.example.com;

	location / {
		proxy_pass http://backend_cluster;
	}
}

Métodos de balanceo:

# round-robin (por defecto)
# least_conn; (menos conexiones activas)
# ip_hash; (persistencia por IP)
# hash $cookie_sessionid consistent;

🔒 SSL / TLS Configuración segura

server {
	listen 443 ssl http2;
	server_name example.com;

	ssl_certificate /etc/ssl/certs/example.crt;
	ssl_certificate_key /etc/ssl/private/example.key;
	ssl_protocols TLSv1.2 TLSv1.3;
	ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM';
	ssl_prefer_server_ciphers on;
	ssl_session_cache shared:SSL:10m;
	ssl_session_timeout 1h;

	add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
	add_header X-Frame-Options DENY;
	add_header X-Content-Type-Options nosniff;

	location / {
		proxy_pass http://backend:3000;
	}
}

Redirección HTTP → HTTPS

server {
	listen 80;
	server_name example.com;
	return 301 https://$host$request_uri;
}

Comandos SSL

openssl req -newkey rsa:2048 -nodes -keyout example.key -x509 -days 365 -out example.crt
openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
certbot --nginx -d example.com -d www.example.com

🧰 Logs y depuración

access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log warn;

log_format main '$remote_addr - $remote_user [$time_local] '
				'"$request" $status $body_bytes_sent '
				'"$http_referer" "$http_user_agent"';

Ver actividad

tail -f /var/log/nginx/access.log
tail -f /var/log/nginx/error.log

🧮 Performance

gzip on;
gzip_types text/plain application/json application/javascript text/css;
gzip_min_length 1024;

keepalive_timeout 65;
sendfile on;
tcp_nopush on;
tcp_nodelay on;

Cache estática

location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
	expires 30d;
	add_header Cache-Control "public, no-transform";
}

🧭 Docker y NGINX

Dockerfile

FROM nginx:stable
COPY ./nginx.conf /etc/nginx/nginx.conf
EXPOSE 80 443

docker-compose.yml

version: '3.8'
services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/ssl/certs:ro
      - ./logs:/var/log/nginx
    networks:
      - proxy_net

networks:
  proxy_net:
    driver: bridge

🔌 Proxy Manager / API Gateway

# Acceder al panel Nginx Proxy Manager (Docker)
http://localhost:81

# Crear Proxy Host
# - Dominio: app.local
# - Forward Hostname / IP: backend
# - Forward Port: 3000
# - SSL: Let’s Encrypt (auto-renovación)

Ejemplo configuración DNS local (hosts)

127.0.0.1 app.local

🧠 Utilidades avanzadas

# Reiniciar NGINX dentro de contenedor
docker exec -it nginx nginx -s reload

# Ver archivos de configuración activos
docker exec -it nginx cat /etc/nginx/nginx.conf

# Generar certificado auto-firmado
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout mysite.key -out mysite.crt -subj "/CN=mysite.local"

🌍 HTTP/2 / HTTP/3 / QUIC

server {
	listen 443 ssl http2;
	# Para HTTP/3 (requiere nginx-quic build)
	listen 443 quic reuseport;

	add_header Alt-Svc 'h3=":443"; ma=86400';
	add_header QUIC-Status $quic;
}

🧾 Redirecciones, subdominios y DNS

server {
	listen 80;
	server_name blog.example.com;
	location / {
		proxy_pass http://blog_backend:4000;
	}
}

DuckDNS / DNS dinámico

curl "https://www.duckdns.org/update?domains=mydomain&token=<TOKEN>&ip="

🔐 Mutual TLS (mTLS)

ssl_verify_client on;
ssl_client_certificate /etc/ssl/certs/ca.crt;

🔍 Diagnóstico

curl -I http://localhost
curl -vk https://example.com
sudo netstat -tulpn | grep nginx
sudo lsof -i :443

📦 Useful paths (Linux)

/etc/nginx/nginx.conf
/etc/nginx/sites-available/
/etc/nginx/sites-enabled/
/var/log/nginx/

📚 Referencias

omnivore nginx

type: list
name: "Notas con #nginx en Omnivore"
order:
  - property: date_saved
    direction: desc
columns:
  - file.name
  - date_saved
filters:
  and:
    - file.inFolder("Omnivore")
    - file.hasTag("nginx")
views:
  - type: table
    name: Table
    sort:
      - property: file.mtime
        direction: DESC