一文彻底明白Nginx到底是什么

原文地址：https://blog.csdn.net/wuzhiwei549/article/details/122758937

什么是Nginx？

Nginx是一个 轻量级/高性能的反向代理Web服务器，用于 HTTP、HTTPS、SMTP、POP3 和 IMAP 协议。他实现非常高效的反向代理、负载平衡，他可以处理2-3万并发连接数，官方监测能支持5万并发，现在中国使用nginx网站用户有很多，例如：新浪、网易、 腾讯等。

Nginx 有哪些优点？

• 跨平台、配置简单。
• 非阻塞、高并发连接：处理 2-3 万并发连接数，官方监测能支持 5 万并发。
• 内存消耗小：开启 10 个 Nginx 才占 150M 内存。
• 成本低廉，且开源。
• 稳定性高，宕机的概率非常小。
• 内置的健康检查功能：如果有一个服务器宕机，会做一个健康检查，再发送的请求就不会发送到宕机的服务器>-了。重新将请求提交到其他的节点上

Nginx 应用场景？

• http服务器。Nginx是一个http服务可以独立提供http服务。可以做网页静态服务器。
• 虚拟主机。可以实现在一台服务器虚拟出多个网站，例如个人网站使用的虚拟机。
• 反向代理，负载均衡。当网站的访问量达到一定程度后，单台服务器不能满足用户的请求时，需要用多台服务器集群可以使用nginx做反向代理。并且多台服务器可以平均分担负载，不会应为某台服务器负载高宕机而某台服务器闲置的情况。
• nginx 中也可以配置安全管理、比如可以使用Nginx搭建API接口网关,对每个接口服务进行拦截。

Nginx 怎么处理请求的？

server {
    
     # 第一个Server区块开始，表示一个独立的虚拟主机站点
   listen       80；# 提供服务的端口，默认80
   server_name localhost; # 提供服务的域名主机名
   location / {
    
     # 第一个location区块开始
     root   html; # 站点的根目录，相当于Nginx的安装目录
     index  index.html index.html; # 默认的首页文件，多个用空格分开
} #第一个location区块结果

• 首先，Nginx 在启动时，会解析配置文件，得到需要监听的端口与 IP 地址，然后在 Nginx 的 Master 进程里面先初始化好这个监控的Socket(创建 S ocket，设置 addr、reuse 等选项，绑定到指定的 ip 地址端口，再 listen 监听)。
• Dann erstellen Sie mit Fork (ein vorhandener Prozess kann die Fork-Funktion aufrufen, um einen neuen Prozess zu erstellen. Der durch Fork erstellte neue Prozess wird als untergeordneter Prozess bezeichnet) mehrere untergeordnete Prozesse.
• Anschließend konkurriert der untergeordnete Prozess um die Annahme neuer Verbindungen. An diesem Punkt kann der Client eine Verbindung zu Nginx initiieren. Wenn der Client einen Drei-Wege-Handshake mit Nginx durchführt und eine Verbindung mit Nginx herstellt. Zu diesem Zeitpunkt akzeptiert ein bestimmter Unterprozess erfolgreich, ruft den Socket der hergestellten Verbindung ab und erstellt dann die Nginx-Kapselung der Verbindung, dh die Struktur ngx_connection_t.
• Als nächstes legen Sie die Verarbeitungsfunktionen für Lese- und Schreibereignisse fest und fügen Lese- und Schreibereignisse hinzu, um Daten mit dem Client auszutauschen.
• Schließlich schließt Nginx oder der Client aktiv die Verbindung. An diesem Punkt endet eine Verbindung.

Wie erreicht Nginx eine hohe Parallelität?

Wenn ein Server einen Prozess (oder Thread) verwendet, um für eine Anfrage verantwortlich zu sein, dann ist die Anzahl der Prozesse die Anzahl der Parallelität. Es ist offensichtlich, dass viele Prozesse warten werden. Worauf wartest du? Am wahrscheinlichsten ist es, auf die Netzwerkübertragung zu warten.

Die asynchrone, nicht blockierende Arbeitsmethode von Nginx nutzt diese Wartezeit. Wenn sie warten müssen, befinden sich diese Prozesse im Leerlauf und im Standby-Modus. Daher löst eine kleine Anzahl von Prozessen eine große Anzahl von Parallelitätsproblemen.

Wie verwendet Nginx es? Einfach ausgedrückt: Wenn dieselben vier Prozesse verwendet werden, ist ein Prozess für eine Anfrage verantwortlich. Wenn dann vier Anfragen gleichzeitig eingehen, ist jeder Prozess bis zur Sitzung für eine davon verantwortlich ist geschlossen. Wenn in diesem Zeitraum eine fünfte Anfrage eingeht. Es ist unmöglich, rechtzeitig zu antworten, da die vier Prozesse ihre Arbeit noch nicht abgeschlossen haben. Daher gibt es normalerweise einen Planungsprozess. Immer wenn eine neue Anfrage eingeht, wird ein neuer Prozess geöffnet, um diese zu bearbeiten.

Nginx ist nicht so. Jedes Mal, wenn eine Anfrage eingeht, gibt es einen Arbeitsprozess, der sie verarbeitet. Aber es ist nicht der gesamte Prozess. In welchem ​​Umfang? Prozess, bei dem eine Blockierung auftreten kann, z. B. die Weiterleitung der Anfrage an den Upstream-Server (Backend) und das Warten auf die Rückgabe der Anfrage. Dann wird der Verarbeitungsarbeiter nicht so dumm warten, sondern nach dem Senden der Anfrage ein Ereignis registrieren: „Wenn der Upstream zurückkehrt, sagen Sie es mir und ich werde fortfahren.“ Also ging er zur Ruhe. Wenn zu diesem Zeitpunkt eine weitere Anfrage eingeht, kann er diese auf diese Weise schnell bearbeiten. Sobald der Upstream-Server zurückkehrt, wird dieses Ereignis ausgelöst, der Worker übernimmt und die Anfrage wird weiterhin ausfallen.

Aus diesem Grund basiert Nginx auf dem Ereignismodell.
Da die Arbeitsweise des Webservers bestimmt, dass der Großteil der Lebensdauer jeder Anfrage in der Netzwerkübertragung liegt, ist die tatsächliche Zeit, die auf dem Servercomputer verbracht wird, nicht viel. Dies ist das Geheimnis, um hohe Parallelität mit nur wenigen Prozessen zu lösen. Das heißt:
Der Webserver ist zufällig eine Netzwerk-IO-intensive Anwendung, keine rechenintensive Anwendung.
Asynchron, nicht blockierend, mit Epoll und in vielen Details optimiert. Es ist auch der technische Eckpfeiler von Nginx.

Was ist ein Forward-Proxy?

Ein Server, der sich zwischen dem Client und dem Ursprungsserver befindet. Um Inhalte vom Ursprungsserver abzurufen, sendet der Client eine Anfrage an den Proxy und gibt das Ziel (Ursprungsserver) an. Der Proxy leitet die Anfrage dann an den Ursprungsserver weiter und ruft ab Der Inhalt wird an den Client zurückgegeben.

Nur Clients können Forward-Proxys verwenden. Die Zusammenfassung des Forward-Proxys besteht nur aus einem Satz: Der Agent fungiert als Agent für den Client. Zum Beispiel: Wir verwenden OpenVPN und so weiter.

Was ist ein Reverse-Proxy?

Die Reverse-Proxy-Methode bezieht sich auf die Verwendung eines Proxyservers zum Akzeptieren von Verbindungsanforderungen im Internet. Anschließend wird die Anforderung an den Server im internen Netzwerk gesendet und die vom Server erhaltenen Ergebnisse an den Client zurückgegeben, der die Verbindung im Internet anfordert. , at Dieses Mal erscheint der Proxy-Server nach außen hin als Reverse-Proxy-Server.
Die Zusammenfassung des Reverse-Proxys besteht nur aus einem Satz: Der Agent fungiert als Proxy für den Server.

Was sind die Vorteile von Reverse-Proxy-Servern?

Reverse-Proxy-Server können die Existenz und Eigenschaften des Ursprungsservers verbergen. Es fungiert als Zwischenschicht zwischen der Internet-Cloud und den Webservern. Dies ist aus Sicherheitsgründen großartig, insbesondere wenn Sie einen Webhosting-Dienst nutzen.

Wie ist die Verzeichnisstruktur von Nginx?

├── client_body_temp
├── conf # Nginx所有配置文件的目录
│ ├── fastcgi.conf # fastcgi相关参数的配置文件
│ ├── fastcgi.conf.default         # fastcgi.conf的原始备份文件
│ ├── fastcgi_params # fastcgi的参数文件
│ ├── fastcgi_params.default       
│ ├── koi-utf
│ ├── koi-win
│ ├── mime.types # 媒体类型
│ ├── mime.types.default
│ ├── nginx.conf # Nginx主配置文件
│ ├── nginx.conf.default
│ ├── scgi_params # scgi相关参数文件
│ ├── scgi_params.default  
│ ├── uwsgi_params # uwsgi相关参数文件
│ ├── uwsgi_params.default
│ └── win-utf
├── fastcgi_temp # fastcgi临时数据目录
├── html # Nginx默认站点目录
│ ├── 50x.html # 错误页面优雅替代显示文件，例如当出现502错误时会调用此页面
│ └── index.html # 默认的首页文件
├── logs # Nginx日志目录
│ ├── access.log # 访问日志文件
│ ├── error.log # 错误日志文件
│ └── nginx.pid # pid文件，Nginx进程启动后，会把所有进程的ID号写到此文件
├── proxy_temp # 临时目录
├── sbin # Nginx命令目录
│ └── nginx # Nginx的启动命令
├── scgi_temp # 临时目录
└── uwsgi_temp # 临时目录

Welche Attributmodule hat die Nginx-Konfigurationsdatei nginx.conf?

worker_processes  1；# worker进程的数量
events {
    
     # 事件区块开始
    worker_connections  1024；# 每个worker进程支持的最大连接数
} # 事件区块结束
http {
    
     # HTTP区块开始
    include       mime.types；# Nginx支持的媒体类型库文件
    default_type application/octet-stream；# 默认的媒体类型
    sendfile on；# 开启高效传输模式
    keepalive_timeout 65；# 连接超时
    server {
    
     # 第一个Server区块开始，表示一个独立的虚拟主机站点
        listen       80；# 提供服务的端口，默认80
        server_name localhost；# 提供服务的域名主机名
        location / {
    
     # 第一个location区块开始
            root   html；# 站点的根目录，相当于Nginx的安装目录
            index index.html index.htm；# 默认的首页文件，多个用空格分开
        } # 第一个location区块结果
        error_page 500502503504  /50x.html；# 出现对应的http状态码时，使用50x.html回应客户
        location = /50x.html {
    
     # location区块开始，访问50x.html
            root   html；# 指定对应的站点目录为html
        }
    }
    ......

Warum verwendet Nginx kein Multithreading?

Apache: Erstellen Sie mehrere Prozesse oder Threads, und jeder Prozess oder Thread weist ihm CPU und Speicher zu (Threads sind viel kleiner als Prozesse, daher unterstützen Worker eine höhere Parallelität als Perfork). Übermäßige Parallelität belastet Serverressourcen.

Nginx: Verwendet einen einzelnen Thread, um Anforderungen asynchron und nicht blockierend zu verarbeiten (der Administrator kann die Anzahl der Arbeitsprozesse im Nginx-Hauptprozess konfigurieren) (epoll). Es werden keine CPU- und Speicherressourcen für jede Anforderung zugewiesen, wodurch viel gespart wird Ressourcen und Reduzierung des Zeitaufwands. Viel CPU-Kontextwechsel. Aus diesem Grund unterstützt Nginx eine höhere Parallelität.

Der Unterschied zwischen Nginx und Apache

Es ist leichtgewichtig, dient auch als Webdienst und benötigt weniger Speicher und Ressourcen als Apache.
Anti-Parallelität: Nginx verarbeitet Anforderungen asynchron und nicht blockierend, während Apache blockiert. Bei hoher Parallelität kann Nginx geringe Ressourcen, geringen Verbrauch und hohe Leistung aufrechterhalten.
Hochmodularer Aufbau, das Schreiben von Modulen ist relativ einfach.
Der Hauptunterschied besteht darin, dass Apache ein synchrones Multiprozessmodell ist, eine Verbindung einem Prozess entspricht, während Nginx asynchron ist und mehrere Verbindungen einem Prozess entsprechen können.

Was ist die Trennung zwischen dynamischen Ressourcen und statischen Ressourcen?

Durch die Trennung von dynamischen Ressourcen und statischen Ressourcen können dynamische Webseiten in dynamischen Websites nach bestimmten Regeln unveränderliche Ressourcen von sich häufig ändernden Ressourcen unterscheiden. Nachdem die dynamischen und statischen Ressourcen aufgeteilt wurden, können wir sie entsprechend den Eigenschaften der statischen Ressourcen trennen. Die Durchführung von Caching-Vorgängen ist die Kernidee der statischen Website-Verarbeitung.
Eine einfache Zusammenfassung der Trennung dynamischer Ressourcen und statischer Ressourcen lautet: die Trennung dynamischer Dateien und statischer Dateien.

Warum müssen wir dynamisch und statisch trennen?

In unserer Softwareentwicklung erfordern einige Anforderungen eine Hintergrundverarbeitung (z. B. .jsp, .do usw.) und einige Anforderungen erfordern keine Hintergrundverarbeitung (z. B. CSS-, HTML-, JPG-, JS- usw. Dateien). Diese Dateien, die nicht im Hintergrund verarbeitet werden müssen, werden als statische Dateien bezeichnet, andernfalls handelt es sich um dynamische Dateien.

Daher ignoriert unsere Hintergrundverarbeitung statische Dateien. Jemand wird sagen, dass es vorbei ist, wenn ich die statischen Dateien im Hintergrund ignoriere? Natürlich ist das möglich, aber die Anzahl der Hintergrundanfragen wird deutlich zunehmen. Wenn wir Anforderungen an die Reaktionsgeschwindigkeit von Ressourcen haben, sollten wir diese dynamische und statische Trennungsstrategie verwenden, um das Problem der dynamischen und statischen Trennung zu lösen. Stellen Sie statische Website-Ressourcen (HTML, JavaScript, CSS, IMG und andere Dateien) getrennt von Hintergrundanwendungen bereit um die Benutzererfahrung zu verbessern. Geschwindigkeit des Zugriffs auf statischen Code und Reduzierung des Zugriffs auf Hintergrundanwendungen

Hier legen wir die statischen Ressourcen in Nginx ab und leiten die dynamischen Ressourcen an den Tomcat-Server weiter.
Da CDN-Dienste wie Qiniu und Alibaba Cloud inzwischen sehr ausgereift sind, besteht der gängige Ansatz natürlich darin, statische Ressourcen in CDN-Diensten zwischenzuspeichern, um die Zugriffsgeschwindigkeit zu erhöhen.

Im Vergleich zum lokalen Nginx verfügt der CDN-Server über mehr Knoten im Land und kann Benutzern einen Zugriff in der Nähe ermöglichen. Darüber hinaus können CDN-Dienste eine größere Bandbreite bereitstellen, im Gegensatz zu unseren eigenen Anwendungsdiensten, die eine begrenzte Bandbreite bereitstellen.

Was ist ein CDN-Dienst?

CDN, Content-Delivery-Netzwerk.
Sein Zweck besteht darin, dem bestehenden Internet eine neue Ebene der Netzwerkarchitektur hinzuzufügen, um Website-Inhalte am Rand des Netzwerks zu veröffentlichen, der den Benutzern am nächsten liegt, sodass Benutzer die benötigten Inhalte in der Nähe erhalten und die Geschwindigkeit, mit der Benutzer auf die Website zugreifen, verbessern können.
Da CDN-Dienste heutzutage relativ beliebt sind, werden grundsätzlich alle Unternehmen CDN-Dienste nutzen.

Wie trennt Nginx dynamisch von statisch?

Sie müssen lediglich das dem Pfad entsprechende Verzeichnis angeben. location/ kann mit regulären Ausdrücken abgeglichen werden. Und geben Sie das entsprechende Verzeichnis auf der Festplatte an.
Wie folgt: (Alle Vorgänge erfolgen unter Linux)

location /image/ {
    
    
    root /usr/local/static/;
    autoindex on;
}
步骤：
# 创建目录
mkdir /usr/local/static/image
 
# 进入目录
cd  /usr/local/static/image
 
# 上传照片
1.jpg
 
# 重启nginx
sudo nginx -s reload

打开浏览器 输入 server_name/image/1.jpg 就可以访问该静态图片了

Wie wird der Nginx-Lastausgleichsalgorithmus implementiert? Welche Strategien gibt es?

Um Serverabstürze zu vermeiden, wird jeder den Lastausgleich nutzen, um den Serverdruck zu verteilen. Die Plattformserver werden zu einem Cluster zusammengefasst. Wenn ein Benutzer zugreift, greift er zuerst auf einen Weiterleitungsserver zu, und dann verteilt der Weiterleitungsserver den Zugriff auf Server mit weniger Druck.

Es gibt fünf Strategien, die durch den Nginx-Lastausgleich implementiert werden:

• (1) Polling (Standard)
  Jede Anfrage wird nacheinander in chronologischer Reihenfolge verschiedenen Back-End-Servern zugewiesen. Fällt ein Back-End-Server aus, kann das fehlerhafte System automatisch eliminiert werden.

upstream backserver {
    
    
 server 192.168.0.1;
 server 192.168.0.2;
}

• (2) Gewichtung
  Je größer der Gewichtungswert, desto höher die zugewiesene Zugriffswahrscheinlichkeit. Sie wird hauptsächlich verwendet, wenn die Leistung jedes Back-End-Servers unausgeglichen ist. Der zweite Schritt besteht darin, in der Master-Slave-Situation unterschiedliche Gewichte festzulegen, um eine angemessene und effektive Nutzung der Host-Ressourcen zu erreichen.

# 权重越高，在被访问的概率越大，如上例，分别是20%，80%。
upstream backserver {
    
    
 server 192.168.0.1 weight=2;
 server 192.168.0.2 weight=8;
}

• (3) ip_hash (IP-Bindung)
  weist jede Anfrage entsprechend dem Hash-Ergebnis der Zugriffs-IP zu, sodass Besucher von derselben IP auf einen Back-End-Server zugreifen können, und kann das Problem der Sitzungsfreigabe dynamischer Webseiten effektiv lösen.

upstream backserver {
    
    
 ip_hash;
 server 192.168.0.1:88;
 server 192.168.0.2:80;
}

• (4) Fair (Plug-In eines Drittanbieters)
  muss das Modul upstream_fair installieren.
  Im Vergleich zu Weight und IP_Hash, bei denen es sich um intelligentere Lastausgleichsalgorithmen handelt, kann der Fair-Algorithmus den Lastausgleich basierend auf Seitengröße und Ladezeit intelligent durchführen und diejenigen mit kurzen Antwortzeiten priorisieren.

# 哪个服务器的响应速度快，就将请求分配到那个服务器上。
upstream backserver {
    
    
 server server1;
 server server2;
 fair;
}

• (5) url_hash (Plug-in eines Drittanbieters)
  muss das Nginx-Hash-Softwarepaket installieren
  , um Anforderungen entsprechend dem Hash-Ergebnis der aufgerufenen URL zuzuordnen, sodass jede URL an denselben Back-End-Server weitergeleitet wird, was die Leistung weiter verbessern kann Effizienz des Back-End-Cache-Servers.

upstream backserver {
    
    
 server squid1:3128;
 server squid2:3128;
 hash $request_uri;
 hash_method crc32;
}

Wie löst man mit Nginx domänenübergreifende Front-End-Probleme?

Verwenden Sie Nginx, um Anfragen weiterzuleiten. Schreiben Sie domänenübergreifende Schnittstellen als Schnittstellen der lokalen Domäne und leiten Sie diese Schnittstellen dann an die tatsächliche Anforderungsadresse weiter.

Wie konfiguriere ich den virtuellen Nginx-Host?

• 1. Virtueller Host anhand des Domänennamens. Unterscheiden Sie den virtuellen Host anhand des Domänennamens – Anwendung: externe Website
• 2. Portbasierter virtueller Host, unterscheiden Sie den virtuellen Host durch den Port – Anwendung: unternehmensinterne Website, Verwaltungs-Backend der externen Website
• 3. IP-basierter virtueller Host.

Konfigurieren Sie den Domänennamen basierend auf dem virtuellen Host

Es ist erforderlich, das Verzeichnis /data/www /data/bbs zu erstellen und den lokalen Windows-Hosts die Domänennamenauflösung hinzuzufügen, die der IP-Adresse der virtuellen Maschine entspricht. Fügen Sie dem entsprechenden Domänennamen-Website-Verzeichnis eine index.html-Datei hinzu.

# 当客户端访问www.lijie.com,监听端口号为80,直接跳转到data/www目录下文件
server {
    
    
    listen       80;
    server_name  www.lijie.com;
    location / {
    
    
        root   data/www;
        index  index.html index.htm;
    }
}

# 当客户端访问www.lijie.com,监听端口号为80,直接跳转到data/bbs目录下文件
 server {
    
    
    listen       80;
    server_name  bbs.lijie.com;
    location / {
    
    
        root   data/bbs;
        index  index.html index.htm;
    }
}

Portbasierte virtuelle Hosts
verwenden Ports zur Unterscheidung, und Browser verwenden Domänennamen oder IP-Adressen: Portnummern für den Zugriff

# 当客户端访问www.lijie.com,监听端口号为8080,直接跳转到data/www目录下文件
 server {
    
    
    listen       8080;
    server_name  8080.lijie.com;
    location / {
    
    
        root   data/www;
        index  index.html index.htm;
    }
}

# 当客户端访问www.lijie.com,监听端口号为80直接跳转到真实ip服务器地址 127.0.0.1:8080
server {
    
    
    listen       80;
    server_name  www.lijie.com;
    location / {
    
    
         proxy_pass http://127.0.0.1:8080;
        index  index.html index.htm;
    }
}

Welche Rolle spielt der Standort?

Die Funktion der Standortanweisung besteht darin, verschiedene Anwendungen entsprechend der vom Benutzer angeforderten URI auszuführen, dh mit der vom Benutzer angeforderten Website-URL übereinzustimmen. Wenn die Übereinstimmung erfolgreich ist, werden relevante Vorgänge ausgeführt.

~ 代表输入的字母

Beispiel für einen regulären Standort:

# 优先级1,精确匹配，根路径
location =/ {
    
    
    return 400;
}

# 优先级2,以某个字符串开头,以av开头的，优先匹配这里，区分大小写
location ^~ /av {
    
    
   root /data/av/;
}

# 优先级3，区分大小写的正则匹配，匹配/media*****路径
location ~ /media {
    
    
      alias /data/static/;
}

# 优先级4 ，不区分大小写的正则匹配，所有的****.jpg|gif|png 都走这里
location ~* .*\.(jpg|gif|png|js|css)$ {
    
    
   root  /data/av/;
}

# 优先7，通用匹配
location / {
    
    
    return 403;
}

Wie kann der Stromfluss begrenzt werden?

Die Nginx-Strombegrenzung dient dazu, die Geschwindigkeit der Benutzeranforderung zu begrenzen, um eine Überlastung des Servers zu verhindern.
Es gibt drei Arten der Strombegrenzung:

• Normalerweise die Zugriffshäufigkeit begrenzen (normaler Verkehr)
• Burst-Limit-Zugriffsfrequenz (Burst-Verkehr)
• Begrenzen Sie die Anzahl gleichzeitiger Verbindungen

Die Strombegrenzung von Nginx basiert auf dem Leaky-Bucket-Flow-Algorithmus

• 1. Normalerweise die Zugriffshäufigkeit begrenzen (normaler Verkehr):

Begrenzen Sie die von einem Benutzer gesendeten Anfragen und wie oft Nginx eine Anfrage erhält.
Das Modul ngx_http_limit_req_module wird in Nginx zur Begrenzung der Zugriffshäufigkeit verwendet. Das Prinzip der Begrenzung basiert im Wesentlichen auf dem Prinzip des Leaky-Bucket-Algorithmus. In der Konfigurationsdatei nginx.conf können Sie die Befehle limit_req_zone und limit_req verwenden, um die Häufigkeit der Anforderungsverarbeitung einer einzelnen IP zu begrenzen.

# 定义限流维度，一个用户一分钟一个请求进来，多余的全部漏掉
limit_req_zone $binary_remote_addr zone=one:10m rate=1r/m;

# 绑定限流维度
server{
    
    
    
    location/seckill.html{
    
    
        limit_req zone=zone;
        proxy_pass http://lj_seckill;
    }

}

1r/s stellt eine Anfrage pro Sekunde dar und 1r/m empfängt eine Anfrage pro Minute. Wenn Nginx zu diesem Zeitpunkt noch Anfragen anderer Personen hat, die noch nicht verarbeitet wurden, weigert sich Nginx, die Anfrage des Benutzers zu verarbeiten.

• 2. Burst-Limit-Zugriffsfrequenz (Burst-Verkehr):

Begrenzen Sie die von einem Benutzer gesendeten Anfragen und wie oft Nginx eine erhält.
Die obige Konfiguration kann die Zugriffsfrequenz bis zu einem gewissen Grad einschränken, es gibt jedoch auch ein Problem: Wenn der Burst-Verkehr die Anforderung überschreitet und abgelehnt wird, kann er den Burst-Verkehr während des Ereignisses nicht verarbeiten. Wie sollen wir zu diesem Zeitpunkt weiter damit umgehen? ?
Nginx stellt den Burst-Parameter in Kombination mit dem Nodelay-Parameter bereit, um das Problem von Verkehrsbursts zu lösen. Sie können die Anzahl der Anfragen, die verarbeitet werden können, über die festgelegte Anzahl der Anfragen hinaus festlegen, die verarbeitet werden können. Wir können Burst-Parameter und Nodelay-Parameter zum vorherigen Beispiel hinzufügen:

# 定义限流维度，一个用户一分钟一个请求进来，多余的全部漏掉
limit_req_zone $binary_remote_addr zone=one:10m rate=1r/m;

# 绑定限流维度
server{
    
    
    
    location/seckill.html{
    
    
        limit_req zone=zone burst=5 nodelay;
        proxy_pass http://lj_seckill;
    }

}

Warum gibt es ein zusätzliches Burst=5 Nodelay;? Das Hinzufügen kann bedeuten, dass Nginx die ersten fünf Anfragen eines Benutzers sofort verarbeitet und die redundanten Anfragen langsam verarbeitet werden. Wenn keine Anfragen von anderen Benutzern vorliegen, werde ich dies tun Verarbeiten Sie Ihre. Wenn es andere Anfragen gibt, wird Nginx diese übersehen und Ihre Anfrage nicht akzeptieren.

• 3. Begrenzen Sie die Anzahl gleichzeitiger Verbindungen

Das Modul ngx_http_limit_conn_module in Nginx bietet die Funktion zur Begrenzung der Anzahl gleichzeitiger Verbindungen, die mithilfe der Direktive limit_conn_zone und der Ausführung von limit_conn konfiguriert werden kann. Als nächstes können wir es anhand eines einfachen Beispiels betrachten:

http {
    
    
    limit_conn_zone $binary_remote_addr zone=myip:10m;
    limit_conn_zone $server_name zone=myServerName:10m;
}

server {
    
    
    location / {
    
    
        limit_conn myip 10;
        limit_conn myServerName 100;
        rewrite / http://www.lijie.net permanent;
    }
}

Oben wurde konfiguriert, dass die maximale Anzahl gleichzeitiger Verbindungen für eine einzelne IP nur 10 betragen kann und die maximale Anzahl gleichzeitiger Verbindungen für den gesamten virtuellen Server nur auf 100 eingestellt werden kann. Natürlich wird die Anzahl der Verbindungen zum virtuellen Server erst gezählt, nachdem der Anforderungsheader vom Server verarbeitet wurde. Wie bereits erwähnt, basiert die Implementierung von Nginx auf dem Prinzip des Leaky-Bucket-Algorithmus. Tatsächlich wird die Strombegrenzung im Allgemeinen auf der Grundlage des Leaky-Bucket-Algorithmus und des Token-Bucket-Algorithmus implementiert.

Kennen Sie den Leaky-Bucket-Flow-Algorithmus und den Token-Bucket-Algorithmus?

• Leaky-Bucket-Algorithmus

Die Idee des Leaky-Bucket-Algorithmus ist sehr einfach. Wir vergleichen Wasser mit einer Anforderung und den Leaky-Bucket mit der Grenze der Systemverarbeitungskapazität. Wasser gelangt zuerst in den Leaky-Bucket und das Wasser im Leaky-Bucket fließt zu einem bestimmten Zeitpunkt ab Rate. Wenn die Abflussrate geringer als die Zuflussrate ist. Zu diesem Zeitpunkt läuft aufgrund der begrenzten Kapazität des undichten Eimers das anschließend direkt eintretende Wasser über (Ablehnung der Anforderung), wodurch eine Durchflussbegrenzung erreicht wird.

• Token-Bucket-Algorithmus

Das Prinzip des Token-Bucket-Algorithmus ist ebenfalls relativ einfach. Wir können ihn als Krankenhausregistrierung für eine medizinische Behandlung verstehen. Erst nach Erhalt der Nummer kann der Arzt eine Diagnose stellen.
Das System verwaltet einen Token-Bucket und legt Token mit konstanter Geschwindigkeit in den Bucket. Wenn zu diesem Zeitpunkt eine Anfrage eingeht und verarbeitet werden soll, müssen Sie zuerst einen Token aus dem Bucket abrufen. ), wenn keine vorhanden ist Ist das Token im Bucket verfügbar, wird der Anforderung der Dienst verweigert. Der Token-Bucket-Algorithmus begrenzt Anforderungen, indem er die Kapazität des Buckets und die Rate, mit der Token ausgegeben werden, steuert.

Wie konfiguriere ich Hochverfügbarkeit in Nginx?

Wenn der Upstream-Server (echter Zugriffsserver) ausfällt oder nicht rechtzeitig antwortet, sollte er direkt zum nächsten Server rotiert werden, um eine hohe Verfügbarkeit des Servers sicherzustellen.

Nginx-Konfigurationscode:

server {
    
    
        listen       80;
        server_name  www.lijie.com;
        location / {
    
    
            ### 指定上游服务器负载均衡服务器
            proxy_pass http://backServer;
            ###nginx与上游服务器(真实访问的服务器)超时时间 后端服务器连接的超时时间_发起握手等候响应超时时间
            proxy_connect_timeout 1s;
            ###nginx发送给上游服务器(真实访问的服务器)超时时间
            proxy_send_timeout 1s;
            ### nginx接受上游服务器(真实访问的服务器)超时时间
            proxy_read_timeout 1s;
            index  index.html index.htm;
        }
    }

Wie stellt Nginx fest, dass auf eine andere IP nicht zugegriffen werden kann?

# 如果访问的ip地址为192.168.0.111,则返回403
 if  ($remote_addr = 192.168.0.111) {
    
    
     return 403;
 }

Wie kann in Nginx verhindert werden, dass eine Anfrage mit einem undefinierten Servernamen verarbeitet wird?
Es kann einfach der Server definiert werden, an den die Anfrage gesendet wird:
Der Servername bleibt als leere Zeichenfolge übrig, er entspricht der Anfrage ohne das Host-Header-Feld und es wird ein spezieller, nicht standardmäßiger Nginx-Code zurückgegeben, wodurch die Verbindung beendet wird.
Wie kann ich den Browserzugriff einschränken?

## 不允许谷歌浏览器访问 如果是谷歌浏览器返回500
if ($http_user_agent ~ Chrome) {
    
    
  return 500;
}
Rewrite全局变量是什么？
$remote_addr //获取客户端ip
$binary_remote_addr //客户端ip（二进制)
$remote_port //客户端port，如：50472
$remote_user //已经经过Auth Basic Module验证的用户名
$host //请求主机头字段，否则为服务器名称，如:blog.sakmon.com
$request //用户请求信息，如：GET ?a=1&b=2 HTTP/1.1
$request_filename //当前请求的文件的路径名，由root或alias和URI request组合而成，如：/2013/81.html
$status //请求的响应状态码,如:200
$body_bytes_sent // 响应时送出的body字节数数量。即使连接中断，这个数据也是精确的,如：40
$content_length // 等于请求行的“Content_Length”的值
$content_type // 等于请求行的“Content_Type”的值
$http_referer // 引用地址
$http_user_agent // 客户端agent信息,如：Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.76 Safari/537.36
$args //与$query_string相同 等于当中URL的参数(GET)，如a=1&b=2
$document_uri //与$uri相同 这个变量指当前的请求URI，不包括任何参数(见$args) 如:/2013/81.html
$document_root //针对当前请求的根路径设置值
$hostname //如：centos53.localdomain
$http_cookie //客户端cookie信息
$cookie_COOKIE //cookie COOKIE变量的值
$is_args //如果有$args参数，这个变量等于”?”，否则等于”"，空值，如?
$limit_rate //这个变量可以限制连接速率，0表示不限速
$query_string // 与$args相同 等于当中URL的参数(GET)，如a=1&b=2
$request_body // 记录POST过来的数据信息
$request_body_file //客户端请求主体信息的临时文件名
$request_method //客户端请求的动作，通常为GET或POST,如：GET
$request_uri //包含请求参数的原始URI，不包含主机名，如：/2013/81.html?a=1&b=2
$scheme //HTTP方法（如http，https）,如：http
$uri //这个变量指当前的请求URI，不包括任何参数(见$args) 如:/2013/81.html
$request_completion //如果请求结束，设置为OK. 当请求未结束或如果该请求不是请求链串的最后一个时，为空(Empty)，如：OK
$server_protocol //请求使用的协议，通常是HTTP/1.0或HTTP/1.1，如：HTTP/1.1
$server_addr //服务器IP地址，在完成一次系统调用后可以确定这个值
$server_name //服务器名称，如：blog.sakmon.com
$server_port //请求到达服务器的端口号,如：80

Wie implementiert Nginx die Integritätsprüfung von Backend-Diensten?

• 1. Verwenden Sie die nginx-eigenen Module ngx_http_proxy_module und ngx_http_upstream_module, um Gesundheitsprüfungen auf den Back-End-Knoten durchzuführen.
• 2. (Empfohlen) verwenden Sie das Modul nginx_upstream_check_module, um Integritätsprüfungen auf den Backend-Knoten durchzuführen.

Wie aktiviere ich die Komprimierung in Nginx?

Nach dem Aktivieren der Nginx-GZIP-Komprimierung wird die Größe statischer Ressourcen wie Webseiten, CSS und JS erheblich reduziert, wodurch viel Bandbreite gespart, die Übertragungseffizienz verbessert und Benutzern ein schnelleres Erlebnis geboten werden kann. Obwohl es CPU-Ressourcen verbraucht, lohnt es sich, den Benutzern ein besseres Erlebnis zu bieten.
Die aktivierte Konfiguration ist wie folgt:

http {
    
    
  # 开启gzip
  gzip on;
 
  # 启用gzip压缩的最小文件；小于设置值的文件将不会被压缩
  gzip_min_length 1k;
 
  # gzip 压缩级别 1-10
  gzip_comp_level 2;
 
  # 进行压缩的文件类型。
 
  gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png;
 
  # 是否在http header中添加Vary: Accept-Encoding，建议开启
  gzip_vary on;
}

Fügen Sie die obige Konfiguration in den http{...}-Knoten von nginx.conf ein.

Speichern Sie Nginx, starten Sie es neu, aktualisieren Sie die Seite (um Zwischenspeicherung zu vermeiden, erzwingen Sie bitte die Aktualisierung) und Sie werden den Effekt sehen. Verwenden Sie am Beispiel von Google Chrome F12, um den Antwortheader der Anfrage anzuzeigen.

Welche Rolle spielt ngx_http_upstream_module?

ngx_http_upstream_module wird verwendet, um Servergruppen zu definieren, auf die durch die Direktiven „fastcgi pass“, „proxy pass“, „uwsgi pass“, „memcached pass“ und „scgi pass“ verwiesen werden kann.

Was ist das C10K-Problem?

Das C10K-Problem bezieht sich auf einen Netzwerk-Socket, der nicht mit einer großen Anzahl von Clients (10.000) gleichzeitig umgehen kann.

Unterstützt Nginx das Komprimieren von Anfragen im Upstream?

Sie können das Nginx-Modul gunzip verwenden, um Anfragen im Upstream zu komprimieren. Das gunzip-Modul ist ein Filter, der Antworten mithilfe von „content-encoding:gzip“ für Clients oder Server dekomprimiert, die die Kodierungsmethode „gzip“ nicht unterstützen.

Wie erhalte ich die aktuelle Uhrzeit in Nginx?

要获得Nginx的当前时间，必须使用SSI模块、和date_local的变量。
Proxy_set_header THE-TIME $date_gmt;

用Nginx服务器解释-s的目的是什么?

用于运行Nginx -s参数的可执行文件。

如何在Nginx服务器上添加模块?

在编译过程中，必须选择Nginx模块，因为Nginx不支持模块的运行时间选择。

生产中如何设置worker进程的数量呢？

在有多个cpu的情况下，可以设置多个worker，worker进程的数量可以设置到和cpu的核心数一样多，如果在单个cpu上起多个worker进程，那么操作系统会在多个worker之间进行调度，这种情况会降低系统性能，如果只有一个cpu，那么只启动一个worker进程就可以了。

nginx状态码

499：
服务端处理时间过长，客户端主动关闭了连接。

502：
(1).FastCGI进程是否已经启动
(2).FastCGI worker进程数是否不够
(3).FastCGI执行时间过长

fastcgi_connect_timeout 300;
fastcgi_send_timeout 300;
fastcgi_read_timeout 300;

(4).FastCGI Buffer不够，nginx和apache一样，有前端缓冲限制，可以调整缓冲参数
fastcgi_buffer_size 32k;
fastcgi_buffers 8 32k;

(5). Der Proxy-Puffer reicht nicht aus. Wenn Sie Proxying verwenden, stellen Sie „
proxy_buffer_size“ auf 16 KB ein;
„proxy_buffers 4“ auf 16 KB.

(6).php-Skriptausführungszeit ist zu lang.
Ändern Sie die Nullen in php-fpm.conf in eine Zeit