Cómo optimizar Nginx En Linux Server: Guía sencilla

Para optimizar Nginx En un servidor Linux, ajuste los procesos de trabajo y las conexiones para que coincidan. CPU y tráfico, habilitar E/S eficiente (epoll, sendfile), comprimir y almacenar en caché las respuestas, optimizar los protocolos TLS/HTTP y alinear los límites del sistema operativo (ulimits, sysctl) con Nginx Requisitos. Validar la configuración, comparar los cambios y supervisar las métricas para garantizar mejoras reales en el rendimiento y la estabilidad.

En esta guía, aprenderás exactamente cómo optimizar Nginx en Linux Server—desde el núcleo Nginx Configuración para el ajuste del kernel de Linux, almacenamiento en caché, TLS y monitorización. Escrito para administradores principiantes e intermedios, este manual paso a paso refleja más de 12 años de experiencia real en alojamiento web. YouStable, ayudándote a obtener el máximo rendimiento, seguridad y eficiencia de Nginx.

Qué significa “Optimización” para Nginx

La optimización no es un simple ajuste; es una alineación de toda la pila entre Nginx, su solicitud (PHP-FPM, Node.js, Python), y el sistema operativoEl objetivo es gestionar más solicitudes por segundo con menor latencia y uso de recursos, sin sacrificar la estabilidad, la seguridad ni la capacidad de mantenimiento.

Antes del vuelo: Confirme su línea base

• Actualizar a una versión compatible Nginx compilar (preferiblemente la rama principal para características y correcciones).
• Conozca su carga de trabajo: archivos estáticos, proxy inverso, PHP-FPM, Node.js o una combinación de ambos.
• Comprobar CPU núcleos RAM, tipo de disco (SSD/NVMe) y capacidad de red.
• Límites actuales de auditoría: abrir archivos, somaxconn, comportamiento TIME_WAIT, parámetros del kernel.

nginx -V
nginx -t
lscpu
ulimit -n
sysctl net.core.somaxconn net.ipv4.ip_local_port_range

Nuestras Nginx La optimización del rendimiento

1) Procesos y conexiones de los trabajadores

Establecer trabajadores para que coincidan con la condición física CPU núcleos, y permitir suficientes conexiones por trabajador para satisfacer la concurrencia máxima. Para la mayoría de los usos web, Nginx Es eficiente, se basa en eventos y requiere menos procesos.

# /etc/nginx/nginx.conf
user  nginx;
worker_processes  auto;
worker_rlimit_nofile  200000;

events {
    use epoll;
    worker_connections  65535;
    multi_accept on;
    # accept_mutex off; # Off for high connection churn, test both
}

Consejo: Asegúrese de que los límites de archivos abiertos del sistema y los límites de unidades de systemd sean superiores a Nginxnecesidades.

# /etc/systemd/system/nginx.service.d/limits.conf
[Service]
LimitNOFILE=200000

2) Buffers, Keep-Alive y tiempos de espera

Los buffers de tamaño adecuado y los tiempos de espera razonables evitan el sobrepeso de la memoria y las conexiones colgadas.

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;

    keepalive_timeout  15;
    keepalive_requests 1000;

    client_header_buffer_size 1k;
    large_client_header_buffers 2 8k;
    client_body_buffer_size 16k;

    client_max_body_size 32m;

    # Timeouts
    client_body_timeout 10s;
    client_header_timeout 10s;
    send_timeout 10s;
}

3) Compresión Gzip o Brotli

Comprimir recursos de texto ahorra ancho de banda y agiliza la entrega. Gzip es ampliamente compatible; Brotli ofrece una mejor compresión para recursos estáticos.

# Gzip (built-in)
gzip on;
gzip_comp_level 5;
gzip_min_length 256;
gzip_types text/plain text/css application/javascript application/json application/xml image/svg+xml;
gzip_vary on;

Para Brotli, instale el módulo y habilítelo como una alternativa directa o junto con gzip para los clientes que lo admitan.

4) TLS y HTTP/2 (y HTTP/3 si está disponible)

Los protocolos modernos reducen la latencia. Utilice HTTP/2 para la multiplexación y habilite cifrados robustos y acelerados por hardware. Si su compilación es compatible con QUIC/HTTP/3, realice pruebas exhaustivas antes de su lanzamiento a producción.

server {
    listen 443 ssl http2; # add "quic reuseport" if built with HTTP/3
    server_name example.com;

    ssl_certificate /etc/ssl/certs/fullchain.pem;
    ssl_certificate_key /etc/ssl/private/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256';
    ssl_prefer_server_ciphers off;

    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:50m; # ~400k sessions
    ssl_session_tickets off;

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

5) Entrega de archivos estáticos y encabezados de almacenamiento en caché

Sirva contenido estático directamente desde Nginx con encabezados de caché para minimizar la revalidación y la carga de origen.

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

Optimización Nginx como proxy inverso

6) Keep-Alive y buffers ascendentes

Mantenga las conexiones ascendentes activas para reducir la sobrecarga del protocolo de enlace. Ajuste los búferes para estabilizar el flujo de respuesta sin acumular memoria.

upstream api_backend {
    server 127.0.0.1:3000 max_fails=3 fail_timeout=10s;
    keepalive 64;
}

location /api/ {
    proxy_pass http://api_backend;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $remote_addr;

    proxy_buffers 16 32k;
    proxy_busy_buffers_size 64k;
    proxy_read_timeout 30s;
}

7) PHP- Ajuste de FPM y FastCGI

La mayoría de WordPress/PHP cuello de botella de los sitios en PHP-FPM. Utilice sockets persistentes y microcaché para reducir la sobrecarga dinámica.

upstream php {
    server unix:/run/php/php-fpm.sock;
    keepalive 32;
}

fastcgi_cache_path /var/cache/nginx/fastcgi levels=1:2 keys_zone=PHP:100m inactive=60m max_size=2g;
map $request_method $skip_cache { default 0; POST 1; }

location ~ .php$ {
    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_pass unix:/run/php/php-fpm.sock;

    fastcgi_read_timeout 30s;
    fastcgi_buffers 16 16k;
    fastcgi_buffer_size 32k;

    # Microcache
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    fastcgi_cache PHP;
    fastcgi_cache_valid 200 301 302 1m;
    add_header X-Cache $upstream_cache_status;
}

Excluye rutas personalizadas o sesiones iniciadas del almacenamiento en caché para evitar servir contenido privado a otros.

8) Proxy/Microcaching para API

El microalmacenamiento en caché con TTL corto suaviza los picos de tráfico para los puntos finales almacenables en caché sin riesgos de obsolescencia.

proxy_cache_path /var/cache/nginx/proxy levels=1:2 keys_zone=API:100m inactive=30m max_size=1g;

location /v1/ {
    proxy_cache API;
    proxy_cache_valid 200 10s;
    proxy_cache_use_stale error timeout updating http_502 http_503 http_504;
    add_header X-Cache $upstream_cache_status;
}

Ajuste del kernel de Linux y del sistema operativo

La configuración de Linux debe coincidir NginxPatrones de concurrencia y conexión. Estos ajustes de sysctl son puntos de partida seguros; realice pruebas de rendimiento y ajústelos según su carga de trabajo.

# /etc/sysctl.d/99-nginx.conf
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 16384
net.ipv4.ip_local_port_range = 1024 65000
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_max_syn_backlog = 4096
net.ipv4.tcp_syncookies = 1
fs.file-max = 500000

sysctl --system
echo "* soft nofile 200000" >> /etc/security/limits.conf
echo "* hard nofile 200000" >> /etc/security/limits.conf

En sistemas multinúcleo con mucha actividad, pruebe la afinidad del puerto de reutilización y la IRQ para las interrupciones de red. Implemente siempre de forma incremental.

Registro, observabilidad y evaluación comparativa

9) Registros de acceso y almacenamiento en búfer

Registrar cada solicitud estática es costoso. Desactívelo para activos y escrituras en búfer para rutas dinámicas.

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

access_log /var/log/nginx/access.log main buffer=128k flush=1s;

10) Métricas y estado

Habilite stub_status o un exportador para alimentar Prometheus/Grafana. Monitoree las conexiones activas, las tasas de solicitudes, la latencia de subida, la tasa de aciertos de caché y los errores.

location /nginx_status {
    stub_status;
    allow 127.0.0.1;
    deny all;
}

11) Benchmark antes y después

Utilice concurrencia y tamaños de carga realistas. Compare percentiles de latencia (p50/p95/p99), no solo promedios.

# Example tools
wrk -t4 -c400 -d30s https://example.com/
ab -n 20000 -c 200 https://example.com/

Fortalecimiento de la seguridad mientras se optimiza

• Ocultar versión: server_tokens off;
• HSTS, opciones de tipo de contenido X, opciones de marco X, política de referencia y una política de seguridad de contenido robusta.
• Limite las tasas de solicitud y las conexiones para mitigar el abuso.

server_tokens off;

limit_req_zone $binary_remote_addr zone=req_per_ip:10m rate=10r/s;
limit_conn_zone $binary_remote_addr zone=conn_per_ip:10m;

location / {
    limit_req zone=req_per_ip burst=20 nodelay;
    limit_conn conn_per_ip 20;
}

Trampas comunes a evitar

• Sobreasignar conexiones de trabajador sin aumentar los límites de archivos del sistema operativo.
• Dejar los tiempos de espera predeterminados demasiado altos provoca una retención de recursos al estilo slowloris.
• Habilitar el almacenamiento en caché agresivo para páginas específicas del usuario (por ejemplo, administración de WordPress, carrito).
• Falta la desuso del push del servidor HTTP/2 y se depende de ella; utilice sugerencias de precarga en su lugar.
• Ignorar los cuellos de botella ascendentes (DB, PHP-FPM) y culpando Nginx.

Ejemplo de configuración paso a paso

A continuación se muestra una línea base segura y de alto rendimiento que puede adaptar. Siempre valide con nginx -t y prepare antes de la producción.

user nginx;
worker_processes auto;
worker_rlimit_nofile 200000;

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

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

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;

    keepalive_timeout 15;
    keepalive_requests 1000;

    # Compression
    gzip on;
    gzip_comp_level 5;
    gzip_min_length 256;
    gzip_types text/plain text/css application/json application/javascript application/xml image/svg+xml;
    gzip_vary on;

    # Logging
    log_format main '$remote_addr - $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent" '
                    '$request_time $upstream_response_time';
    access_log /var/log/nginx/access.log main buffer=128k flush=1s;
    error_log /var/log/nginx/error.log warn;

    # Caches
    proxy_cache_path /var/cache/nginx/proxy levels=1:2 keys_zone=API:100m inactive=30m max_size=1g;
    fastcgi_cache_path /var/cache/nginx/fastcgi levels=1:2 keys_zone=PHP:100m inactive=60m max_size=2g;

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

    # Site
    server {
        listen 80;
        listen 443 ssl http2;
        server_name example.com;
        root /var/www/html;
        index index.php index.html;

        ssl_certificate /etc/ssl/certs/fullchain.pem;
        ssl_certificate_key /etc/ssl/private/privkey.pem;
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_session_cache shared:SSL:50m;

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

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

        location / {
            try_files $uri $uri/ /index.php?$args;
        }

        location ~ .php$ {
            include fastcgi_params;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_pass unix:/run/php/php-fpm.sock;
            fastcgi_read_timeout 30s;
            fastcgi_buffers 16 16k;
            fastcgi_buffer_size 32k;
            fastcgi_cache PHP;
            fastcgi_cache_valid 200 301 302 1m;
            add_header X-Cache $upstream_cache_status;
        }
    }
}

Lista de verificación de validación e implementación

• nginx -t pasa; la configuración está bajo control de versiones.
• Se han superado los límites del sistema (nofile, somaxconn). Nginx demandas.
• Comparación de rendimiento antes y después; monitorizar la latencia p95, RPS, CPU, memoria.
• Las reglas de caché excluyen los puntos finales personalizados o de administración.
• Puntuación TLS probada; HTTP/2 habilitado; Brotli/Gzip verificado a través de encabezados de respuesta.
• Los registros de acceso se almacenan en búfer; los registros de activos se deshabilitan.
• Plan de reversión listo; cambios implementados durante poco tráfico.

Cuándo elegir hosting administrado

Si prefiere resultados sin prueba y error, considere una manageel VPS or servidor dedicado. En YouStable, nuestros ingenieros preajustan Nginx, PHP-FPM y el kernel de Linux configuran el almacenamiento en caché y la observabilidad, y optimizan continuamente para su carga de trabajo, de modo que obtenga el máximo rendimiento con menos riesgos y tiempo de inactividad.

Alineando Nginx configuración, almacenamiento en caché, TLS y parámetros del kernel de Linux con su carga de trabajo real, y al validar cada cambio, puede obtener mejoras significativas en el rendimiento y la experiencia del usuario. Si desea que expertos se encarguen de esto de principio a fin, YouStable, manageLos servidores d están diseñados para la velocidad desde el primer día.

Preguntas frecuentes: Cómo optimizar Nginx en un servidor Linux