Maison > Article > Opération et maintenance > Comment Nginx et Tomcat réalisent la séparation dynamique et statique et l'équilibrage de charge
Comment Nginx et Tomcat réalisent la séparation dynamique et statique et l'équilibrage de charge
- 王林avant
- 2023-05-18 17:10:06885parcourir
1. Introduction à nginx :
nginx est un serveur http et proxy inverse hautes performances avec une grande stabilité et prend en charge le déploiement à chaud et l'extension facile des modules. Lorsqu'il rencontre un pic d'accès ou que quelqu'un initie par malveillance une connexion lente, il est également probable que la mémoire physique du serveur soit épuisée et fréquemment échangée, entraînant une perte de réponse. Le serveur ne peut être redémarré que par étapes. La technologie d'allocation pour traiter les fichiers statiques et l'accélération du proxy inverse sans cache permettent d'équilibrer la charge et de tolérer les pannes, et peuvent résister à un traitement à haute concurrence dans de telles situations d'accès à haute concurrence.
II. Installation et configuration de nginx
Étape 1 : Téléchargez le package d'installation de nginx
Étape 2 : Installez nginx sur Linux
#tar zxvf nginx-1.7.8.tar.gz //解压 #cd nginx-1.7.8 #./configure --with-http_stub_status_module --with-http_ssl_module//启动server状态页和https模块
signalera une erreur de bibliothèque PCRE manquante, comme indiqué dans l'image :
À ce moment , Exécutez d'abord la troisième étape pour installer pcre, puis exécutez-la en 3, c'est tout
4.make && make install //Compile et install
5 Testez si la configuration d'installation est correcte, nginx est installé dans /usr. /local/nginx
#/usr/local/nginx/sbin/nginx -t, comme indiqué sur l'image :
Étape 3 : Installez pcre sur Linux
#tar zxvf pcre-8.10.tar.gz //解压 cd pcre-8.10 ./configure make && make install//编译并安装
Trois. nginx + tomcat réalise une séparation dynamique et statique
La séparation dynamique et statique signifie que nginx traite les pages statiques (pages html) ou les images demandées par le client, et tomcat traite les pages dynamiques (pages jsp) demandées par le client, en raison de l'efficacité des pages statiques traitées par nginx Supérieure à Tomcat.
Première étape : nous devons configurer le fichier nginx
#vi /usr/local/nginx/conf/nginx.conf
#user nobody;
worker_processes 1;
error_log logs/error.log;
pid logs/nginx.pid;
events {
use epoll;
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;
sendfile on;
keepalive_timeout 65;
gzip on;
gzip_min_length 1k;
gzip_buffers 4 16k;
gzip_http_version 1.0;
gzip_comp_level 2;
gzip_types text/plain application/x-javascript text/css application/xml;
gzip_vary on;
server {
listen 80 default;
server_name localhost;
<span style="color:#ff0000;"> location ~ .*\.(html|htm|gif|jpg|jpeg|bmp|png|ico|txt|js|css)$ //由nginx处理静态页面</span>
{
root /usr/tomcat/apache-tomcat-8081/webapps/root;
expires 30d; //缓存到客户端30天
}
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;
}
<span style="color:#ff0000;"> location ~ \.(jsp|do)$ {//所有jsp的动态请求都交给tomcat处理 </span>
<span style="color:#ff0000;"> proxy_pass http://192.168.74.129:8081; //来自jsp或者do的后缀的请求交给tomcat处理</span>
proxy_redirect off;
proxy_set_header host $host; //后端的web服务器可以通过x-forwarded-for获取用户真实ip
proxy_set_header x-real-ip $remote_addr;
proxy_set_header x-forwarded-for $proxy_add_x_forwarded_for;
client_max_body_size 10m; //允许客户端请求的最大单文件字节数
client_body_buffer_size 128k; //缓冲区代理缓冲用户端请求的最大字节数
proxy_connect_timeout 90; //nginx跟后端服务器连接超时时间
proxy_read_timeout 90; //连接成功后，后端服务器响应时间
proxy_buffer_size 4k; //设置代理服务器（nginx）保存用户头信息的缓冲区大小
proxy_buffers 6 32k; //proxy_buffers缓冲区，网页平均在32k以下的话，这样设置
proxy_busy_buffers_size 64k;//高负荷下缓冲大小（proxy_buffers*2）
proxy_temp_file_write_size 64k; //设定缓存文件夹大小，大于这个值，将从upstream服务器传
}
}
}Étape deux : Créer une nouvelle page statique index.html sous webapps/root sous tomcat, Comme le montre l'image :
Étape 3 : Démarrez le service nginx
#sbin/nginx Comme le montre l'image :
Étape 4 : L'accès à notre page peut afficher le contenu normal, comme indiqué dans l'image affichée :
Étape 5 : Tester les performances de nginx et Tomcat dans le traitement de pages statiques sous haute concurrence ?
Utilisation de la commande Linux ab website stress test pour tester les performances
1. Testez les performances de nginx dans le traitement des pages statiques
ab -c 100 -n 1000
Cela signifie traiter 100 requêtes en même temps et exécuter le indexez 1000 fois le fichier html, comme indiqué dans l'image :
2 Testez les performances de Tomcat dans le traitement des pages statiques
ab -c 100 -n 1000
Cela signifie traiter 100 requêtes en même temps. et exécutez le fichier index.html 1000 fois, comme le montre la figure :
Pour le même traitement de fichiers statiques, les performances statiques du traitement nginx sont meilleures que celles de Tomcat. nginx peut demander 5 388 fois par seconde, tandis que Tomcat ne demande que 2 609 fois.
Résumé : Dans le fichier de configuration nginx, nous attribuons une configuration statique à nginx pour le traitement et des requêtes dynamiques à tomcat, ce qui améliore les performances.
Quatre. Équilibrage de charge nginx + Tomcat et tolérance aux pannes
Afin d'améliorer les performances du serveur et de réduire la pression de concurrence sur un seul serveur dans des conditions de concurrence élevée, nous adoptons le déploiement de cluster, qui peut également résoudre le problème d'empêcher un seul serveur de raccrocher. Dans ce cas, le service n'est pas accessible pour gérer les problèmes de tolérance aux pannes.
La première étape : Nous avons déployé le serveur Tomcat ici pendant deux jours, 192.168.74.129:8081 et 192.168.74.129:8082
La deuxième étape : nginx est utilisé comme serveur proxy, et l'équilibrage de charge est utilisé lorsque le client le demande le serveur. à traiter, afin que les demandes des clients puissent être réparties uniformément sur les serveurs chaque jour, réduisant ainsi la pression sur le serveur. Configurez le fichier nginx.conf sous nginx.
#vi /usr/local/nginx/conf/nginx.conf
#user nobody;
worker_processes 1;
error_log logs/error.log;
pid logs/nginx.pid;
events {
use epoll;
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;
sendfile on;
keepalive_timeout 65;
gzip on;
gzip_min_length 1k;
gzip_buffers 4 16k;
gzip_http_version 1.0;
gzip_comp_level 2;
gzip_types text/plain application/x-javascript text/css application/xml;
gzip_vary on;
<span style="color:#ff0000;">upstream localhost_server {
ip_hash;
server 192.168.74.129:8081;
server 192.168.74.129:8082;
}</span>
server {
listen 80 default;
server_name localhost;
<span style="color:#ff0000;"> location ~ .*\.(html|htm|gif|jpg|jpeg|bmp|png|ico|txt|js|css)$ //由nginx处理静态页面</span>
{
root /usr/tomcat/apache-tomcat-8081/webapps/root;
expires 30d; //缓存到客户端30天
}
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;
}
<span style="color:#ff0000;">location ~ \.(jsp|do)$ {//所有jsp的动态请求都交给tomcat处理 </span>
<span style="color:#ff0000;">proxy_pass http://localhost_server; //来自jsp或者do的后缀的请求交给tomcat处理</span>
proxy_redirect off;
proxy_set_header host $host; //后端的web服务器可以通过x-forwarded-for获取用户真实ip
proxy_set_header x-real-ip $remote_addr;
proxy_set_header x-forwarded-for $proxy_add_x_forwarded_for;
client_max_body_size 10m; //允许客户端请求的最大单文件字节数
client_body_buffer_size 128k; //缓冲区代理缓冲用户端请求的最大字节数
proxy_connect_timeout 90; //nginx跟后端服务器连接超时时间
proxy_read_timeout 90; //连接成功后，后端服务器响应时间
proxy_buffer_size 4k; //设置代理服务器（nginx）保存用户头信息的缓冲区大小
proxy_buffers 6 32k; //proxy_buffers缓冲区，网页平均在32k以下的话，这样设置
proxy_busy_buffers_size 64k;//高负荷下缓冲大小（proxy_buffers*2）
proxy_temp_file_write_size 64k; //设定缓存文件夹大小，大于这个值，将从upstream服务器传
}
}
}Instructions :
1 Le serveur en amont fait référence à l'IP (nom de domaine) et au port du serveur, et peut également être suivi. par paramètres
1 )weight : Définissez le poids de transfert du serveur. La valeur par défaut est 1.
2) max_fails : il est utilisé conjointement avec fail_timeout. Cela signifie que pendant la période fail_timeout, si le nombre d'échecs de transfert du serveur dépasse la valeur définie par max_fails, le serveur ne sera pas disponible. 1
3)fail_timeout : indique combien de fois le transfert échoue pendant cette période avant que le serveur ne soit considéré comme indisponible.
4)down : Indique que ce serveur ne peut pas être utilisé.
5) sauvegarde : indique que le paramètre ip_hash n'est pas valide pour ce serveur. La requête ne sera transmise au serveur qu'après l'échec de tous les serveurs non de sauvegarde.
2.ip_hash est défini sur le serveur du cluster. Si la même requête client est transmise à plusieurs serveurs, chaque serveur peut mettre en cache les mêmes informations, ce qui entraînera un gaspillage de ressources. Le paramètre transmettra les mêmes informations au serveur de la première requête lorsque le même client demandera les mêmes informations pour la deuxième fois. Mais ip_hash ne peut pas être utilisé avec le poids.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!