fichier de configuration nginx
emplacement du fichier de configuration nginx
/usr/local/nginx/conf/nginx.conf
Composition du fichier de configuration Nginx
(1) Bloc global
Du début du fichier de configuration au contenu du bloc d'événements, il s'agit principalement de définir certaines instructions de configuration qui affectent le fonctionnement global du serveur nginx.
Par exemple:
work_processes 1;
plus la valeur de worker_processes est élevée, plus le traitement simultané peut être pris en charge et plus il y a de processus de travail.
Error_log représente le chemin de stockage du journal d'erreurs nginx
(2) bloc d'événements
Les instructions impliquées dans le bloc d'événements affectent principalement la connexion réseau entre le serveur nginx et l'utilisateur. Par
exemple:
worker_connections 1024; le nombre maximum de connexions prises en charge
(3) bloc http
Le bloc http est divisé en bloc global http et bloc serveur
HTTP bloc global:
inclure main.types; introduire un fichier externe -> / main.types mettre un grand nombre de types de média
incluent vhosts / *. conf; introduire un fichier externe -> Importez le fichier de configuration se terminant par .conf sous le fichier vhosts
Bloc serveur:
listent: 80; contrôlez la racine du
bloc d'emplacement du port 89
: / web / abc; envoyez la demande reçue au répertoire spécifié pour demander des ressources.
index: index.html; Par défaut, c'est
le point clé pour trouver le bloc de serveur de fichiers relatif dans le chemin ci - dessus , principalement pour la configuration de divers noms de domaine et projets, et peut être utilisé pour les opérations de proxy inverse.
Cas de proxy inverse
Dans le serveur, remplacez le nom du serveur par l'adresse IP spécifique actuelle, puis ajoutez un proxy_pass à l'emplacement, écrivez l'adresse IP et le numéro de port du serveur spécifique vers lesquels le proxy doit être utilisé et attendez que le client lance une requête sur le port 80 du nginx. serveur, vous pouvez directement proxy vers notre serveur proxy inverse désigné
// 把当前IP的80端口反向代理到当前IP的8080端口
server {
listen 80;
server_name localhost;
location / {
proxy_pass http://127.0.0.1:8080;
}
}
Mappage de chemin d'emplacement Nginx spécifique
#优先级关系(越精确，优先级越高)
(location =) > (location /xxx/zzz/vvv) > (location ^~) > (location ~,~*) > (location /)
#1. = 匹配
location =/ {
#精准匹配，主机名后面不能带任何的的字符串
}
#2. 通用匹配
location /xxx {
#匹配所有以xxx开头的路径
}
#3. 正则匹配
location ~ /xxx {
# 匹配所有以xxx开头的路径
}
#4. 匹配开头路径
location ^~ /xxx {
# 匹配所有以xxx开头的路径
}
#5. ~* \.(gif|jpg|png)$ {
# 匹配以gif或者jpg或者png结尾的路径
}
Cas d'équilibrage de charge
Ajoutez la partie en amont au bloc global http, ajoutez tous les serveurs qui nécessitent un équilibrage de charge et ajoutez des règles, telles que l'ordre de priorité, etc.
Utilisez ensuite proxy_pass dans le bloc serve pour spécifier le nom de l'équilibreur de charge, comme suit, il peut s'agir de l'équilibreur de charge actuel. Chaque demande tombera sur chaque serveur uniformément.
Pour des détails spécifiques, veuillez vous référer aux articles suivants résumés par d'autres:
Description détaillée détaillée de Nginx de la méthode de distribution en amont.
Plus précisément, je coopérerai avec docker pour faire un cas, utiliser docker pour construire deux serveurs nginx et un serveur tomcat, mappez différents numéros de port et laissez l'un d'entre eux au serveur nginx effectuer l'équilibrage de charge.
# 下载并运行一个nginx服务器，映射端口号8011到80端口
$ docker run -d -p 8011:80 --name some-nginx daocloud.io/library/nginx:latest
# 在运行一个nginx容器，映射端口号8012到80端口，4bb46517cac3 为刚才运行的nginx的容器的镜像id
$ docker run -d -p 8012:80 --name some-nginx1 4bb46517cac3
# 下载并运行一个tomcat服务器，映射端口号8082到8080端口， todo 注意tomcat的默认路径下的默认文件存在请求js和css，会多次请求服务器，如果用默认的负载均衡方式会导致负载均衡出问题，最好在tomcat下增加一个index.html文件来做测试，这样每一次访问只会请求到一台服务器，可以很直观的看到效果
$ docker run -d -p 8082:8080 --name t8 daocloud.io/library/tomcat:8.5.15-jre8
# 本地把需要做负载均衡的config配置文件先做好
$ vi default.conf
# default.conf nginx配置文件
upstream myServer{
server 10.0.2.15:8082; # IP 换成自己的
server 10.0.2.15:8012; # IP 换成自己的
}
server {
listen 80;
listen [::]:80;
server_name localhost;
location / {
# root /usr/share/nginx/html;
proxy_pass http://myServer;
index index.html index.htm;
}
}
# 把修改好的配置文件复制到docker的nginx容器(some-nginx)中
$ docker cp ./default.conf some-nginx:/etc/nginx/conf.d/default.conf
# 重启一下
$ docker restart some-nginx
À ce stade, la configuration du serveur est terminée et les résultats peuvent être vérifiés et acceptés en accédant au serveur d'équilibrage de charge dans le navigateur.
Stratégie d'équilibrage de charge
Nginx nous propose trois stratégies d'équilibrage de charge par défaut:
1. Polling: Les requêtes initiées par le client sont réparties uniformément sur chaque serveur
2. Poids: La requête du client sera allouée en fonction de la valeur de poids du serveur
. ip_hash: En fonction des différentes adresses IP du client qui a initié la requête, il enverra toujours la requête au serveur spécifié. C'est-à-dire que si l'adresse IP de la requête du client reste la même, le serveur traitant la requête être toujours le même
vote
Le cas d'interrogation est le cas ci-dessus, c'est très simple, ce qui suit est une description de configuration simple
# 需要轮询的Ip及端口号
upstream my_server{
server ip:port;
server ip:port;
}
server {
listen 80;
listen [::]:80;
server_name localhost;
location / {
proxy_pass http://upstream名称/;
}
}
Poids
Le poids est mis en œuvre en ajoutant du poids à l'arrière de chaque serveur en amont. Les détails sont les suivants. Après avoir configuré les éléments suivants, je réactive le serveur nginx à charge équilibrée créé par docker, puis je lance une requête. Après cinq requêtes au serveur tomcat, il y aura une requête de serveur nginx.
upstream myServer{
server 10.0.2.15:8082 weight=10; # IP 换成自己的
server 10.0.2.15:8012 weight=2; # IP 换成自己的
#server 10.0.2.15:8011;
}
server {
listen 80;
listen [::]:80;
server_name localhost;
#charset koi8-r;
#access_log /var/log/nginx/host.access.log main;
location / {
proxy_pass http://myServer;
#root /usr/share/nginx/html;
index index.html index.htm;
}
}
ip_hash
La réalisation de ip_hash, après avoir ajouté ip_hash dans la première ligne de l'amont, l'ip sera verrouillée, et chaque ip ne demandera qu'un seul serveur. A ce moment, je redémarre le serveur et après avoir fait la requête, je trouverai que seul le le serveur nginx est accessible.
upstream myServer{
ip_hash;
server 10.0.2.15:8082 weight=10; # IP 换成自己的
server 10.0.2.15:8012 weight=2; # IP 换成自己的
#server 10.0.2.15:8011;
}
server {
listen 80;
listen [::]:80;
server_name localhost;
#charset koi8-r;
#access_log /var/log/nginx/host.access.log main;
location / {
proxy_pass http://myServer;
#root /usr/share/nginx/html;
index index.html index.htm;
}
}
Séparation dynamique et statique
Formule de concurrence de Nginx:
worker_processes * worker_connections / 4 | 2 = Capacité de concurrence finale de Nginx
Exigence de ressources dynamiques / 4, exigence de ressources statiques / 2
Nginx améliore la capacité de concurrence de Nginx grâce à une séparation dynamique et statique, et répond plus rapidement aux utilisateurs
Agent de ressources dynamiques
Rien à dire, au fond c'était dynamique avant
#配置如下
location / {
proxy_pass 路径;
}
Agent de ressource statique
# nginx 配置项
server {
listen 80;
listen [::]:80;
server_name localhost;
# 在 /web/data 下创建html文件夹，然后把一个index.html文件放到里边
location /html {
root /web/data;
index index.html;
}
# 在 /web/data 下创建img文件夹，然后把一个123.html文件放到里边
location /img {
root /web/data;
autoindex on; #代表展示静态资源的全部内容，以列表的形式展开
}
}
<!- index.html文件内容， 直接把图片也直接放到了内容中一起请求，看是否可以直接成功 ->
<h1>test img</h1>
<img src="http://192.168.1.113:8013/img/123.jpg"/>
Tout a réussi, la page statique html est accessible normalement, et les images sont également accessibles normalement
Nous examinons le rôle de "l'autoindex sur", comme suit
