Configuración común de Nginx (proxy inverso, equilibrio de carga, separación dinámica y estática, clúster de alta disponibilidad)

1. ¿Qué es Nginx?

Nginx es un servidor proxy inverso y web de alto rendimiento. Como servidor web, es diferente de nuestros servidores de aplicaciones web de uso común (tomcat, jetty): no puede analizar páginas como jsp, pero solo puede analizar html, css y JavaScript; como servidor proxy inverso, se usa ampliamente en el despliegue de nuestra aplicación. Por ejemplo, el despliegue de páginas estáticas, proxy inverso, etc.

2. Instalación

Ventanas

Descárguelo, descomprímalo y úselo de inmediato.

Linux

Ver este tutorial

Mac

Mac se puede instalar como Linux, o puede instalarlo de las siguientes formas:

Consultar si se ha instalado y la información correspondiente

brew info nginx

instalación

brew install nginx

La instalación se ha configurado con variables de entorno y se puede iniciar directamente

puesta en marcha

nginx 

Archivo de configuración

vim /usr/local/etc/nginx/nginx.conf

3. Archivo de configuración detallado

Por ejemplo, después de instalar Linux, tenemos /usr/local/nginx/conf/un nginx.confarchivo de configuración llamado . El contenido predeterminado del archivo de configuración es el siguiente (se han agregado comentarios):

Anotar el archivo de configuración

#user  nobody;
# 启动进程，通常设置成和cpu的数量相等
worker_processes  1;

# 全局错误日志
#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

# PID文件
#pid        logs/nginx.pid;


# 工作模式及连接数上限
events {
    
    
    # 支持最大连接数
    worker_connections  1024;
}


http {
    
    
    #文件扩展名与文件类型映射表
    include       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" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    # 指定 nginx 是否调用 sendfile 函数（zero copy 方式）来输出文件
    sendfile        on;

    #防止网络阻塞
    #tcp_nopush     on;

    # 连接超时时间
    #keepalive_timeout  0;
    keepalive_timeout  65;

    # 开启zip压缩
    #gzip  on;

    # 虚拟主机配置，一个http中可以包含多个server
    server {
    
    
        # 监听端口
        listen       8080;
        # 请求地址（可以是域名或IP地址），多个地址之间用空格隔开
        server_name  localhost;

        # 编码, 如果网页格式与当前配置的不同的话将会被自动转码
        #charset koi8-r;

        #虚拟主机访问日志定义    
        #access_log  logs/host.access.log  main;

        # location对指定路径进行拦截处理（默认路径）    
        location / {
    
    
            # 首页应用路径
            root   html;
            # 首页对应root下的哪个文件
            index  index.html index.htm;
        }

        # 错误信息页面
        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
    
    
            root   html;
        }

        # 代理配置例子：访问URL以.php结尾则自动转交给127.0.0.1
        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
    
    
        #    proxy_pass   http://127.0.0.1;
        #}


        # 转发(类似代理Proxy)： php脚本请求全部代理给FastCGI处理
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
    
    
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # 配置禁止访问 .htxxx文件
        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
    
    
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    
    
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    
    
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    
    
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    
    
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

    include servers/*;
}

4. Colocación habitual

4.1. Proxy inverso

Antes de continuar con la configuración, comprenda algunos conceptos: servidor proxy, proxy de reenvío y proxy inverso.

Servidor proxy

El llamado servidor proxy es un servidor de trampolín ubicado entre el cliente solicitante y el servidor original. El proxy directo puede ocultar al cliente y el proxy inverso puede ocultar el servidor original.

Proxy de reenvío

El usuario conoce la dirección del servidor de destino, pero no puede acceder directamente a él debido a restricciones de red y otras razones. En este momento, primero debe conectarse al servidor proxy y luego el servidor proxy puede acceder al servidor de destino. El servidor de destino del proxy de reenvío no conoce al cliente real.

Proxy inverso

El usuario conoce la dirección del servidor proxy, pero el servidor proxy no es el servidor que finalmente procesa la solicitud del usuario. El servidor proxy pasa la solicitud a un servidor final diferente para su procesamiento a través de la dirección de solicitud del usuario. El usuario del proxy inverso no conoce la dirección del servidor real.

Ejemplo de configuración

Ejemplo 1: Revertimos todas las solicitudes de www.123.com a http://127.0.0.1:8080 para su procesamiento.

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

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

Ejemplo 2: Según la ruta de acceso, la solicitud se entrega a diferentes servicios para su procesamiento.

Visite http://127.0.0.1/edu/ y envíe la solicitud a http://127.0.0.1:8081 para su procesamiento.

Visite http://127.0.0.1/vod/ solicite http://127.0.0.1:8082 para su procesamiento

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

        location ~ /edu/ {
    
    
            proxy_pass http://127.0.0.1:8081;
        }
        
        location ~ /vod/ {
    
    
            proxy_pass http://127.0.0.1:8082;
        }
    }

Descripción de la ubicación

locationSe usa para coincidir con la ruta de la solicitud. La sintaxis es la siguiente:

location [= | ~ | ~* | ^~] url {
    
    

}

• = Se utiliza para la concordancia exacta de URL sin expresiones regulares.
• ~Se utiliza para indicar que la URL contiene una coincidencia de expresión regular y distingue entre mayúsculas y minúsculas.
• ~*Se utiliza para indicar que la URL contiene una coincidencia de expresión regular y no distingue entre mayúsculas y minúsculas.
• ^~Indica que los caracteres ordinarios coinciden. Si esta opción coincide, solo coincide con esta opción y no se combinan otras opciones. Generalmente se utiliza para hacer coincidir directorios.

Si el URI contiene una expresión regular, debe contener ~o ~*identificar

4.2 Equilibrio de carga

¿Qué es el equilibrio de carga?

El equilibrio de carga se entiende literalmente como compartir la presión que uno no puede soportar con los demás para manejar la presión juntos. En nuestro entorno de implementación, significa distribuir las solicitudes a varios servidores para su procesamiento, de modo que los servidores puedan soportar una mayor concurrencia.

Ejemplo de configuración

Las visitas de http://127.0.0.1/edu/1.html lograrán el efecto de equilibrio de carga y se distribuirán uniformemente a los puertos 8080 y 8081 para su procesamiento.

Prepare dos Tomcats (modifique el número de puerto y prepare el archivo 1.html) para comenzar por separado.

nginxConfiguración:

http{
    
    

  upstream myserver{
    
    
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;
  }
  
  server{
    
    
  	listen	80;
  	server_name localhost;
  }
  
  location / {
    
    
  	proxy_pass	http://myserver;
  	root	html;
  	index	index.html	index.htm;
  }
  
}  
  

myserver obtiene un nombre por sí mismo, puede elegirlo a voluntad.

Varias estrategias para que Nginx logre el equilibrio de carga

1. Sondeo (estrategia predeterminada)

Cada solicitud se asigna a diferentes servidores back-end uno por uno en orden cronológico. Si el servidor back-end no funciona, se puede eliminar automáticamente.

2.peso

peso representa el peso y el valor predeterminado es 1. Cuanto mayor sea el peso, más clientes se asignarán.

http{
    
    

  upstream myserver{
    
    
    server 127.0.0.1:8080	weight=10;
    server 127.0.0.1:8081	weight=5;
  }
  
  server{
    
    
  	listen	80;
  	server_name localhost;
  }
  
  location / {
    
    
  	proxy_pass	http://myserver;
  	root	html;
  	index	index.html	index.htm;
  }
  
}  

3.ip_hash

Cada solicitud se asigna de acuerdo con el resultado hash de la ip, de modo que cada visitante tenga acceso fijo a un servidor back-end, que puede resolver el problema de la sesión.

http{
    
    

  upstream myserver{
    
    
  	ip_hash;
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;
  }
  
  server{
    
    
  	listen	80;
  	server_name localhost;
  }
  
  location / {
    
    
  	proxy_pass	http://myserver;
  	root	html;
  	index	index.html	index.htm;
  }
  
}  

4.justo

La solicitud se asigna de acuerdo con el tiempo de respuesta del servidor back-end y se le da prioridad al tiempo de respuesta corto.

http{
    
    

  upstream myserver{
    
    
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;
    fair;
  }
  
  server{
    
    
  	listen	80;
  	server_name localhost;
  }
  
  location / {
    
    
  	proxy_pass	http://myserver;
  	root	html;
  	index	index.html	index.htm;
  }
  
}  

4.3 Separación dinámica y estática

¿Qué es la separación dinámica y estática?

La separación dinámica y estática de Nginx simplemente significa separar los recursos dinámicos de las solicitudes de recursos estáticos. No puede entenderse simplemente como una separación física de páginas dinámicas y páginas estáticas. Estrictamente hablando, las solicitudes dinámicas deben separarse de las solicitudes estáticas (el reenvío de solicitudes diferentes se realiza especificando diferentes sufijos por ubicación, y el tiempo de almacenamiento en caché de los recursos estáticos se configura por expiración); el propósito es mejorar la velocidad de respuesta del sitio web y reducir la carga en el servidor.

Desde la perspectiva de implementación actual, hay aproximadamente dos tipos:

• Una es poner archivos estáticos en un servidor separado, que es el método principal actual;
• Una es que los archivos dinámicos y los archivos dinámicos se mezclan y se liberan por separado a través de la configuración de nginx.

Por ejemplo

Una aplicación que desarrollamos, los recursos estáticos almacenados en el host cuando implementa el datadirectorio, de regreso a la interfaz tienen un /api/prefijo cuando la solicitud enviada por el locationproxy inverso dinámico para interceptar el http://192.168.122.128:8080procesamiento. Cuando se envía una solicitud de recurso estático, se obtiene del host.

http{
    
    
  
  server{
    
    
  	listen	80;
  	server_name localhost;
  }
  
  location /api/ {
    
    
  	proxy_pass	http://192.168.122.128:8080;
  }

# 文件浏览器配置
#  location / {
    
    
#  	root	/;
#  	autoindex	on; #目录索引页
#  }
  
  location ~ .*\.(gif|jpg|jpeg|bmp|png|ico|txt|js|css)$ {
    
     
            root /data/; #宿主机静态资源目录 也可以反向代理到静态资源服务器获取
            expires      3d; # 缓存3天 
        } 
  
} 

4.4 Clúster de alta disponibilidad

Nota: Este caso es solo una prueba de red interna de máquina virtual, no aplicable a pruebas de red pública.

¿Qué es un clúster de alta disponibilidad?

Alta disponibilidad (alta disponibilidad) se abrevia como HA, es decir, a través del diseño para reducir el tiempo que el sistema no puede proporcionar servicios (es decir, para proporcionar servicios en el menor tiempo posible después de un tiempo de inactividad), un clúster es donde varias máquinas trabajan juntas. . En términos simples: un clúster de alta disponibilidad es un sistema compuesto por varias máquinas que pueden continuar brindando servicios en un corto período de tiempo si no funciona.

Hay dos esquemas de configuración para que Nginx configure clústeres de alta disponibilidad

• configuración maestro-esclavo keepalived + nginx

  Este esquema usa una dirección VIP (IP virtual), dos servidores, uno como maestro y el otro como respaldo, pero solo una máquina está funcionando al mismo tiempo, y la otra máquina de respaldo siempre está adentro cuando la máquina principal no lo hace. Estado de desperdicio, para sitios web con pocos servidores, esta solución no es económica.

• configuración de maestro dual keepalived + nginx

  Este tipo de esquema utiliza dos direcciones VIP y dos servidores, cada uno como respaldo principal, y dos máquinas funcionan al mismo tiempo.Cuando una de las máquinas falla, las solicitudes de las dos máquinas se transfieren a una máquina.

Preparación ambiental

Prepare dos servidores (CentOs 7.X se toma como ejemplo aquí).

Este es solo un ejemplo de la configuración de Nginx, no hay otra configuración de proxy inverso (servidores como tomcat).

1. Instale Nginx

Sugerir leer este artículo

2. Instalar Keepalived

yum install keepalived –y

Después de la instalación, hay /etc/más de un keepaliveddirectorio bajo el directorio, y el keepalived.confarchivo de configuración bajo el directorio keepalived es su archivo de configuración.

La función de Keepalived es activar la IP virtual para que el cliente pueda acceder al servicio correspondiente a través de la IP virtual.

3. Escriba el script de detección de nginx (dos máquinas)

vim /etc/keepalived/nginx_check.sh。

#!/bin/bash
A=`ps -C nginx --no-header | wc -l`
if [ $A -eq 0 ];then
    /www/server/nginx/sbin #尝试重新启动nginx
    sleep 2  #睡眠2秒
    if [ `ps -C nginx --no-header | wc -l` -eq 0 ];then
        killall keepalived #启动失败，将keepalived服务杀死。将vip漂移到其它备份节点
    fi
fi

Agregar permisos ejecutableschmod +x /etc/keepalived/nginx_check.sh

Configuración maestro-esclavo

keepalivedConfiguración de host :

global_defs {
    
    
# 收件人
#	notification_email {
    
    
#     [email protected]
#     [email protected]
#     [email protected]
#   }
#   发件人
#   notification_email_from [email protected]
#   发邮件服务器
#		smtp_server 192.168.200.1
#   超时时间
#   smtp_connect_timeout 30
	router_id LVS_DEVEL01  # 局域网keppalived主机身份标识信息(每台唯一)
}


# 集群资源监控，组合track_script进行 
vrrp_script chk_nginx {
    
    
       script "/etc/keepalived/nginx_check.sh"
       interval 2  #每2秒检测一次nginx的运行状态
       weight -20  #失败一次，将自己的优先级-20
}

vrrp_instance VI_1 {
    
    
	state MASTER # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 51 # 主、备机的 virtual_router_id 必须相同
	priority 100 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.50 // VRRP H 虚拟地址
	} 
}

keepalivedConfiguración de la máquina en espera :

global_defs {
    
    
# 收件人
#	notification_email {
    
    
#     [email protected]
#     [email protected]
#     [email protected]
#   }
#   发件人
#   notification_email_from [email protected]
#   发邮件服务器
#		smtp_server 192.168.200.1
#   超时时间
#   smtp_connect_timeout 30
	router_id LVS_DEVEL02  # 局域网keppalived主机身份标识信息(每台唯一)
}


# 集群资源监控，组合track_script进行 
vrrp_script chk_nginx {
    
    
       script "/etc/keepalived/nginx_check.sh"
       interval 2  #每2秒检测一次nginx的运行状态
       weight -20  #失败一次，将自己的优先级-20
}

vrrp_instance VI_1 {
    
    
	state BACKUP # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 51 # 主、备机的 virtual_router_id 必须相同
	priority 90 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.50 // VRRP H 虚拟地址
	} 
}

Prueba :

Iniciar el servicio de nginxsuma keepalivedde las dos máquinas

Inicie nginx:

nginx

Iniciar keepalived

systemctl start keepalived.service

Compruebe si se ha iniciado keepalived

ps -ef | grep keepalived

Ver el enlace de IP virtual del host

ip addr

Acceso a través de IP virtual

El host simulado nginx está inactivo (eliminar el servicio keepalived, matar nginx no funcionará, porque el script de detección correspondiente keepalived detecta que Nginx está muerto e intentará reiniciarse)

systemctl stop keepalived.service

En este momento, puede ver que se ha cambiado al esclavo a través del acceso de IP virtual

Configuración de maestro dual

La primera máquina:

global_defs {
    
    
# 收件人
#	notification_email {
    
    
#     [email protected]
#     [email protected]
#     [email protected]
#   }
#   发件人
#   notification_email_from [email protected]
#   发邮件服务器
#		smtp_server 192.168.200.1
#   超时时间
#   smtp_connect_timeout 30
	router_id LVS_DEVEL01  # 局域网keppalived主机身份标识信息(每台唯一)
}


# 集群资源监控，组合track_script进行 
vrrp_script chk_nginx {
    
    
       script "/etc/keepalived/nginx_check.sh"
       interval 2  #每2秒检测一次nginx的运行状态
       weight -20  #失败一次，将自己的优先级-20
}

vrrp_instance VI_1 {
    
    
	state MASTER # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 51 # 主、备机的 virtual_router_id 必须相同
	priority 100 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.50 // VRRP H 虚拟地址
	} 
}

vrrp_instance VI_1 {
    
    
	state BACKUP # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 52 # 主、备机的 virtual_router_id 必须相同
	priority 90 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.51 // VRRP H 虚拟地址
	} 
}

La segunda máquina:

global_defs {
    
    
# 收件人
#	notification_email {
    
    
#     [email protected]
#     [email protected]
#     [email protected]
#   }
#   发件人
#   notification_email_from [email protected]
#   发邮件服务器
#		smtp_server 192.168.200.1
#   超时时间
#   smtp_connect_timeout 30
	router_id LVS_DEVEL02  # 局域网keppalived主机身份标识信息(每台唯一)
}


# 集群资源监控，组合track_script进行 
vrrp_script chk_nginx {
    
    
       script "/etc/keepalived/nginx_check.sh"
       interval 2  #每2秒检测一次nginx的运行状态
       weight -20  #失败一次，将自己的优先级-20
}

vrrp_instance VI_1 {
    
    
	state BACKUP # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 51 # 主、备机的 virtual_router_id 必须相同
	priority 90 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.50 // VRRP H 虚拟地址
	} 
}

vrrp_instance VI_2 {
    
    
	state MASTER # 备份服务器上将 MASTER 改为 BACKUP 
	interface eth0 # 网卡
	virtual_router_id 52 # 主、备机的 virtual_router_id 必须相同
	priority 100 # 主、备机取不同的优先级，主机值较大，备份机值较小
	advert_int 1
# 设置高可用集群中不抢占功能，在主机down后，从机接管，当主机重新恢复后，主机不抢占备用机
#	nopreempt 
	authentication {
    
    
		auth_type PASS
		auth_pass 1111
	}

# 集群资源监控，组合vrrp_script进行  
  track_script {
    
      
    chk_nginx  
  }	
	virtual_ipaddress {
    
    
		10.211.55.51 // VRRP H 虚拟地址
	} 
}

prueba:

Reinicie las dos máquinaskeepalived服务

systemctl restart keepalived.service

En ambas máquinas, puede ip addrver la dirección IP virtual correspondiente enlazada

Acceso vía IP virtual:

Cuando el nginx de un servicio cuelga, ambos accesos de IP virtuales irán a la misma máquina.