Nginx Cheatsheet Completo

Sumario

1. Instalación y Servicio

2. Estructura de Archivos

3. Sintaxis Básica de Configuración

4. Bloques server (Virtual Hosts)

5. Bloques location

6. Proxy Inverso

7. Balanceo de Carga / Upstream

8. SSL/TLS y Certbot

9. Cabeceras HTTP

10. Compresión (Gzip/Brotli)

11. Caché

12. Limitación de Velocidad (Rate Limiting)

13. Autenticación Básica

14. Redirecciones y Rewrite

15. WebSockets

16. Registros (Logs)

17. Variables Útiles

18. Ajuste de Rendimiento

19. Seguridad

20. Resolución de Problemas

21. Ejemplos Completos

Instalación y Servicio

Instalación (Debian/Ubuntu)

apt update
apt install nginx -y

Instalación (RHEL/Oracle Linux/CentOS)

dnf install nginx -y
# ou em versões antigas:
yum install nginx -y

Instalación desde el repositorio oficial (versión más reciente)

# Debian/Ubuntu
curl -fsSL https://nginx.org/keys/nginx_signing.key | gpg --dearmor | tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/ubuntu $(lsb_release -cs) nginx" | tee /etc/apt/sources.list.d/nginx.list
apt update && apt install nginx

Gestión del servicio (systemd)

systemctl start nginx
systemctl stop nginx
systemctl restart nginx
systemctl reload nginx          # recarga la config sin descartar conexiones
systemctl status nginx
systemctl enable nginx          # habilita en el arranque
systemctl enable --now nginx

Probar y recargar configuración

nginx -t                  # prueba la sintaxis de la config
nginx -T                  # prueba y muestra la config completa (todos los includes resueltos)
nginx -s reload            # envía señal de recarga al proceso maestro
nginx -s stop              # parada inmediata
nginx -s quit              # parada elegante
nginx -V                   # versión + módulos compilados

Estructura de Archivos

Debian/Ubuntu (predeterminado sites-available/sites-enabled)

/etc/nginx/
├── nginx.conf                  # config principal
├── mime.types
├── conf.d/                     # configs adicionales (incluidas automáticamente)
├── sites-available/            # vhosts disponibles (no activos)
├── sites-enabled/              # enlaces simbólicos a sites-available (activos)
├── snippets/                   # fragmentos reutilizables (ssl, headers, etc.)
└── modules-enabled/

/var/log/nginx/
├── access.log
└── error.log

/var/www/html/                  # webroot predeterminado

RHEL/Oracle Linux (predeterminado conf.d)

/etc/nginx/
├── nginx.conf
├── conf.d/                     # *.conf incluidos automáticamente
└── default.d/

/usr/share/nginx/html/          # webroot predeterminado
/var/log/nginx/

Activar un sitio (modelo Debian)

ln -s /etc/nginx/sites-available/meusite.conf /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx

Sintaxis Básica de Configuración

# Estructura general en nginx.conf

user www-data;                  # usuario que ejecuta los procesos worker
worker_processes auto;          # generalmente = nº de núcleos de CPU
pid /run/nginx.pid;

events {
    worker_connections 1024;    # conexiones simultáneas por worker
    use epoll;                  # Linux: epoll es el método más eficiente
    multi_accept on;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

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

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

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

Contextos (jerarquía): main → events/http/mail/stream → server → location. Las directivas en un contexto más interno sobrescriben el externo (herencia selectiva).

Bloques server (Virtual Hosts)

HTTP básico

server {
    listen 80;
    listen [::]:80;
    server_name exemplo.com.br www.exemplo.com.br;

    root /var/www/exemplo.com.br;
    index index.html index.php;

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

Múltiples dominios en el mismo bloque

server {
    listen 80;
    server_name app1.exemplo.com.br app2.exemplo.com.br;
    ...
}

Servidor predeterminado (catch-all)

server {
    listen 80 default_server;
    server_name _;
    return 444;   # cierra la conexión sin respuesta — útil contra escáneres
}

Bloques location

Tipos de coincidencia (orden de prioridad)

location = /exact        { }   # 1. coincidencia EXACTA (mayor prioridad)
location ^~ /prefixo      { }   # 2. prefijo, si coincide (ignora regex)
location ~  /regex$       { }   # 3. regex sensible a mayúsculas
location ~* \.(jpg|png)$  { }   # 4. regex insensible a mayúsculas
location /prefixo         { }   # 5. prefijo común (menor prioridad)

try_files (esencial para SPA/PHP)

# SPA (React/Vue/Angular)
location / {
    try_files $uri $uri/ /index.html;
}

# PHP
location ~ \.php$ {
    try_files $uri =404;
    fastcgi_pass unix:/run/php/php8.3-fpm.sock;
    fastcgi_index index.php;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
}

Servir archivos estáticos con caché

location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff2?|svg)$ {
    expires 30d;
    add_header Cache-Control "public, immutable";
    access_log off;
}

Denegar acceso

location ~ /\.(?!well-known) {
    deny all;          # bloquea archivos ocultos, excepto .well-known (ACME)
}

location /admin {
    allow 192.168.0.0/24;
    allow 10.0.0.0/8;
    deny all;
}

Proxy Inverso

Configuración básica

location / {
    proxy_pass http://127.0.0.1:8080;
    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;
}

Tiempos de espera importantes

proxy_connect_timeout 5s;
proxy_send_timeout    60s;
proxy_read_timeout     60s;
send_timeout            60s;

Buffers (relevante para APIs/cargas grandes)

proxy_buffering on;
proxy_buffer_size 4k;
proxy_buffers 8 4k;
proxy_busy_buffers_size 8k;
client_max_body_size 50m;     # tamaño máximo de subida

Atención con la barra final en proxy_pass

# CON barra final: elimina el prefijo /api/ antes de enviar al backend
location /api/ {
    proxy_pass http://backend:3000/;
}
# /api/users -> http://backend:3000/users

# SIN barra final: mantiene el prefijo /api/
location /api/ {
    proxy_pass http://backend:3000;
}
# /api/users -> http://backend:3000/api/users

Balanceo de Carga / Upstream

Round-robin (predeterminado)

upstream backend_app {
    server 10.0.0.10:8080;
    server 10.0.0.11:8080;
    server 10.0.0.12:8080 backup;   # solo se usa si los otros caen
}

server {
    location / {
        proxy_pass http://backend_app;
    }
}

Estrategias de balanceo

upstream backend_app {
    least_conn;                      # menos conexiones activas
    # ip_hash;                       # sticky session por IP del cliente
    # hash $request_uri consistent;  # sticky por URI (cache distribuido)

    server 10.0.0.10:8080 weight=3;  # pesos diferentes
    server 10.0.0.11:8080 weight=1;
    server 10.0.0.12:8080 max_fails=3 fail_timeout=30s;
}

Chequeos de salud pasivos

server 10.0.0.10:8080 max_fails=2 fail_timeout=10s;

Nginx open-source no tiene chequeo de salud activo nativo — eso es una característica de Nginx Plus. Para activo, usar ngx_http_upstream_check_module (compilación personalizada) o monitoreo externo (ej: Zabbix eliminando nodo del upstream mediante plantilla/script).

Keepalive con upstream (importante para el rendimiento)

upstream backend_app {
    server 10.0.0.10:8080;
    keepalive 32;
}

server {
    location / {
        proxy_pass http://backend_app;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
}

SSL/TLS y Certbot

Bloque SSL básico

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name exemplo.com.br;

    ssl_certificate     /etc/letsencrypt/live/exemplo.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/exemplo.com.br/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_session_tickets off;

    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 1.1.1.1 8.8.8.8 valid=300s;
    resolver_timeout 5s;
}

# Redirect HTTP -> HTTPS
server {
    listen 80;
    server_name exemplo.com.br;
    return 301 https://$host$request_uri;
}

Certbot — emisión y renovación

# Instalación
apt install certbot python3-certbot-nginx -y

# Emitir certificado (modo nginx, edita la config automáticamente)
certbot --nginx -d exemplo.com.br -d www.exemplo.com.br

# Emitir solo el certificado (sin tocar la config)
certbot certonly --nginx -d exemplo.com.br

# Wildcard (requiere plugin DNS, ej: Cloudflare)
certbot certonly --dns-cloudflare \
  --dns-cloudflare-credentials /etc/letsencrypt/cloudflare.ini \
  -d "*.exemplo.com.br" -d "exemplo.com.br"

# Renovación manual / prueba de renovación
certbot renew --dry-run
certbot renew

# Listar certificados
certbot certificates

# Revocar / eliminar
certbot revoke --cert-path /etc/letsencrypt/live/exemplo.com.br/cert.pem
certbot delete --cert-name exemplo.com.br

Renovación automática (cron/temporizador systemd)

# Generalmente ya viene habilitado:
systemctl list-timers | grep certbot

# Probar el hook de recarga de nginx después de la renovación:
certbot renew --deploy-hook "systemctl reload nginx"

Generar dhparam (Diffie-Hellman, más seguridad)

openssl dhparam -out /etc/nginx/dhparam.pem 2048

ssl_dhparam /etc/nginx/dhparam.pem;

Cabeceras HTTP

# Seguridad
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
add_header Content-Security-Policy "default-src 'self'" always;

# Remover header que expone versión de Nginx
server_tokens off;

# CORS básico
add_header 'Access-Control-Allow-Origin' '*' always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'Authorization, Content-Type' always;

always garantiza que la cabecera se envíe incluso en respuestas de error (4xx/5xx).

Compresión (Gzip/Brotli)

Gzip

gzip on;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_min_length 256;
gzip_types
    text/plain
    text/css
    text/xml
    application/json
    application/javascript
    application/xml+rss
    application/x-font-ttf
    font/opentype
    image/svg+xml;

Brotli (requiere módulo ngx_brotli, compilado por separado)

brotli on;
brotli_comp_level 6;
brotli_types text/plain text/css application/json application/javascript;

Caché

Caché de proxy (caché de proxy inverso)

proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=meu_cache:10m
                  max_size=1g inactive=60m use_temp_path=off;

server {
    location / {
        proxy_cache meu_cache;
        proxy_cache_valid 200 302 10m;
        proxy_cache_valid 404 1m;
        proxy_cache_use_stale error timeout updating http_500 http_502 http_503;
        add_header X-Cache-Status $upstream_cache_status;   # HIT/MISS/EXPIRED
        proxy_pass http://backend_app;
    }
}

Caché FastCGI (PHP)

fastcgi_cache_path /var/cache/nginx/fastcgi levels=1:2 keys_zone=php_cache:50m max_size=500m;

location ~ \.php$ {
    fastcgi_cache php_cache;
    fastcgi_cache_valid 200 30m;
    fastcgi_cache_key "$scheme$request_method$host$request_uri";
}

Omisión de caché (útil para depuración y administración)

proxy_cache_bypass $cookie_nocache $arg_nocache;
proxy_no_cache $cookie_nocache;

Limitación de Velocidad (Rate Limiting)

Limitar solicitudes por IP

http {
    limit_req_zone $binary_remote_addr zone=req_limit:10m rate=10r/s;
}

server {
    location /api/ {
        limit_req zone=req_limit burst=20 nodelay;
        limit_req_status 429;
    }
}

Limitar conexiones simultáneas

http {
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;
}

server {
    location / {
        limit_conn conn_limit 10;
    }
}

Limitar ancho de banda (throughput)

location /downloads/ {
    limit_rate_after 10m;   # primeros 10MB sin límite
    limit_rate 500k;        # después, limita a 500KB/s
}

Autenticación Básica

# Generar archivo de contraseña (requiere apache2-utils / httpd-tools)
htpasswd -c /etc/nginx/.htpasswd usuario1
htpasswd /etc/nginx/.htpasswd usuario2   # agregar otro sin -c

location /admin {
    auth_basic "Área restringida";
    auth_basic_user_file /etc/nginx/.htpasswd;
}

Redirecciones y Rewrite

# Redirección simple (301 permanente / 302 temporal)
return 301 https://novo-dominio.com.br$request_uri;
return 302 /pagina-temporaria;

# Redirección de www a non-www (o viceversa)
server {
    listen 80;
    server_name www.exemplo.com.br;
    return 301 https://exemplo.com.br$request_uri;
}

# Rewrite (más pesado, usar con moderación)
rewrite ^/antigo/(.*)$ /novo/$1 permanent;   # 301
rewrite ^/antigo/(.*)$ /novo/$1 redirect;    # 302
rewrite ^/antigo/(.*)$ /novo/$1 last;        # procesa nueva URI internamente
rewrite ^/antigo/(.*)$ /novo/$1 break;       # detiene procesamiento de rewrite, mantiene location actual

Regla general: prefiera return sobre rewrite cuando sea posible — es más predecible y eficiente.

WebSockets

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

server {
    location /ws/ {
        proxy_pass http://backend_ws;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_read_timeout 86400s;   # conexiones largas no deben ser cortadas
    }
}

Registros (Logs)

Formatos personalizados

log_format detailed '$remote_addr - $remote_user [$time_local] '
                     '"$request" $status $body_bytes_sent '
                     '"$http_referer" "$http_user_agent" '
                     'rt=$request_time uct="$upstream_connect_time" '
                     'uht="$upstream_header_time" urt="$upstream_response_time"';

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

Registros por contexto / condicional

# No registrar chequeos de salud
location /health {
    access_log off;
    return 200 "OK";
}

# Registro condicional (ej: solo errores)
map $status $loggable {
    ~^[23]  0;
    default 1;
}
access_log /var/log/nginx/error_only.log combined if=$loggable;

Rotación de registros (logrotate, predeterminado Debian/RHEL)

# /etc/logrotate.d/nginx — generalmente ya viene configurado
cat /etc/logrotate.d/nginx

# Forzar rotación manual
logrotate -f /etc/logrotate.d/nginx

Comandos útiles de análisis

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

# Top IPs
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -20

# Códigos de estado más frecuentes
awk '{print $9}' access.log | sort | uniq -c | sort -rn

# Solicitudes más lentas (con log_format "detailed" arriba)
awk '{print $NF, $7}' access.log | sort -rn | head -20

Variables Útiles

Ajuste de Rendimiento

# events
worker_processes auto;
worker_rlimit_nofile 65535;

events {
    worker_connections 4096;
    use epoll;
    multi_accept on;
}

http {
    # Conexiones
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 30;
    keepalive_requests 1000;

    # Buffers
    client_body_buffer_size 16k;
    client_header_buffer_size 1k;
    large_client_header_buffers 4 8k;
    output_buffers 1 32k;
    postpone_output 1460;

    # Hash tables (evita warnings en configs con muchos server_names)
    server_names_hash_bucket_size 128;

    # Open file cache (reduce syscalls en sitios estáticos)
    open_file_cache max=10000 inactive=20s;
    open_file_cache_valid 60s;
    open_file_cache_min_uses 2;
    open_file_cache_errors on;
}

Calcular worker_connections ideal

max_clients = worker_processes * worker_connections

Para proxy inverso, cada conexión de cliente puede abrir otra hacia el backend — considere el doble.

Seguridad

# Esconder versión de nginx
server_tokens off;

# Limitar métodos HTTP permitidos
if ($request_method !~ ^(GET|HEAD|POST)$) {
    return 405;
}

# Bloquear user-agents maliciosos comunes
if ($http_user_agent ~* (curl|wget|python-requests|scrapy)) {
    return 403;
}

# Bloquear acceso directo por IP (forzar uso de dominio configurado)
server {
    listen 80 default_server;
    server_name _;
    return 444;
}

# Proteger contra clickjacking, sniffing, etc — ver sección Cabeceras HTTP

# Limitar tamaño de subida (evitar DoS)
client_max_body_size 10m;

# Timeout para conexiones lentas (slow loris)
client_body_timeout 10s;
client_header_timeout 10s;

fail2ban (complementario a nginx para fuerza bruta)

apt install fail2ban -y
# Filtro predeterminado: /etc/fail2ban/filter.d/nginx-http-auth.conf
# Jail: /etc/fail2ban/jail.local

Resolución de Problemas

Errores comunes

Comandos de diagnóstico

# Probar configuración
nginx -t

# Ver config completa expandida (todos los includes resueltos)
nginx -T

# Procesos y workers
ps aux | grep nginx

# Conexiones activas
ss -tn state established '( dport = :80 or dport = :443 )' | wc -l

# Estado en tiempo real (requiere stub_status habilitado)
curl http://localhost/nginx_status

# Verificar si el puerto está siendo escuchado
ss -tlnp | grep nginx

# Probar respuesta de un vhost específico (sin alterar DNS)
curl -H "Host: exemplo.com.br" http://127.0.0.1/

# Probar SSL y ver detalles del certificado
openssl s_client -connect exemplo.com.br:443 -servername exemplo.com.br

# Verificar SELinux (RHEL/Oracle Linux) bloqueando proxy
getenforce
setsebool -P httpd_can_network_connect 1

Módulo stub_status (métricas básicas para monitoreo/Zabbix)

server {
    listen 127.0.0.1:8080;
    location /nginx_status {
        stub_status on;
        allow 127.0.0.1;
        deny all;
    }
}

curl http://127.0.0.1:8080/nginx_status
# Active connections, server accepts handled requests, Reading/Writing/Waiting

Ejemplos Completos

1. Sitio estático con SSL y caché de assets

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

server {
    listen 443 ssl;
    http2 on;
    server_name site.com.br;

    ssl_certificate     /etc/letsencrypt/live/site.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/site.com.br/privkey.pem;

    root /var/www/site.com.br;
    index index.html;

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

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

2. Proxy inverso para aplicación Node/Java (ej: Spring Boot)

upstream app_backend {
    server 127.0.0.1:8080;
    keepalive 32;
}

server {
    listen 443 ssl;
    http2 on;
    server_name api.empresa.com.br;

    ssl_certificate     /etc/letsencrypt/live/api.empresa.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.empresa.com.br/privkey.pem;

    client_max_body_size 20m;

    location / {
        proxy_pass http://app_backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        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_connect_timeout 5s;
        proxy_read_timeout 60s;
    }

    location /health {
        access_log off;
        proxy_pass http://app_backend/actuator/health;
    }
}

3. Portal multi-tenant con SSO/enrutamiento basado en ruta (estilo portal-cliente)

upstream portal_frontend { server 127.0.0.1:3000; keepalive 16; }
upstream portal_api      { server 127.0.0.1:8080; keepalive 16; }
upstream guacamole       { server 127.0.0.1:8081; keepalive 16; }

server {
    listen 443 ssl;
    http2 on;
    server_name portal.empresa.com.br;

    ssl_certificate     /etc/letsencrypt/live/portal.empresa.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/portal.empresa.com.br/privkey.pem;

    location /api/ {
        proxy_pass http://portal_api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /guacamole/ {
        proxy_pass http://guacamole/guacamole/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $http_connection;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_buffering off;
    }

    location / {
        proxy_pass http://portal_frontend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

4. Balanceador de carga con terminación SSL y failover

upstream cluster_app {
    least_conn;
    server 10.0.1.10:8080 weight=2 max_fails=3 fail_timeout=20s;
    server 10.0.1.11:8080 weight=2 max_fails=3 fail_timeout=20s;
    server 10.0.1.12:8080 backup;
    keepalive 64;
}

server {
    listen 443 ssl;
    http2 on;
    server_name app.empresa.com.br;

    ssl_certificate     /etc/letsencrypt/live/app.empresa.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/app.empresa.com.br/privkey.pem;

    location / {
        proxy_pass http://cluster_app;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_next_upstream error timeout http_502 http_503 http_504;
        proxy_next_upstream_tries 3;
        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;
    }
}

Referencia Rápida de Comandos

nginx -t                          # probar config
nginx -T                          # probar y mostrar config completa
nginx -s reload                   # recarga elegante
systemctl reload nginx            # idem, vía systemd
journalctl -u nginx -f            # logs del servicio en tiempo real
nginx -V                          # ver módulos compilados
curl -I https://exemplo.com.br    # checar cabeceras de respuesta
openssl s_client -connect host:443 -servername host   # checar SSL

Cheatsheet generado para referencia rápida de administración de Nginx en entornos de producción Linux.