Detaillierte Erläuterung der Installation des Nginx-Servers und der Lastausgleichskonfiguration auf einem Linux-System

nginx (Engine x) ist ein leistungsstarker HTTP- und Reverse-Proxyserver, Mail-Proxyserver und allgemeiner TCP/UDP-Proxyserver. Seine Merkmale sind geringes Gewicht (beansprucht weniger Systemressourcen), gute Stabilität, Skalierbarkeit (modulare Struktur), starke Parallelitätsfähigkeit und einfache Konfiguration.

Dieser Artikel stellt hauptsächlich die grundlegende Lastausgleichsfunktion vor, die von nginx in einer Testumgebung implementiert wird.

nginx kann HTTP-Dienste bereitstellen, darunter die Verarbeitung statischer Dateien, die Unterstützung von SSL- und TLS-SNI, GZIP-Webseitenkomprimierung, virtuelle Hosts, URL-Umschreiben und andere Funktionen, und kann mit FastCGI, uwsgi und anderen Programmen zur Verarbeitung dynamischer Anforderungen verwendet werden.

Darüber hinaus kann nginx auch für Serverfunktionen wie Proxy, Reverse-Proxy, Lastausgleich und Caching verwendet werden, um die Netzwerklast und -verfügbarkeit in einer Clusterumgebung zu verbessern.

1. Erstellen Sie eine Testumgebung

Die Testumgebung besteht hier aus zwei über VirtualBox installierten virtuellen Lubuntu 19.04-Maschinen. Die Installationsmethode des Linux-Systems wird nicht im Detail beschrieben.

Um den gegenseitigen Zugriff zwischen den beiden virtuellen Linux-Maschinen zu gewährleisten, verwendet die Netzwerkkonfiguration der virtuellen Maschinen zusätzlich zur Standard-NAT-Methode die von der VirtualBox-Software bereitgestellte Netzwerkmethode „Internes Netzwerk“ (Intern).

Darüber hinaus müssen Sie die dem „internen Netzwerk“ in den beiden virtuellen Maschinen zugeordneten Netzwerkkarten an die statischen IP-Adressen desselben Netzwerksegments binden, damit die beiden Hosts ein lokales Netzwerk bilden und direkt aufeinander zugreifen können.

Netzwerkkonfiguration

Öffnen Sie die VirtualBox-Software, rufen Sie die Einstellungsoberfläche der beiden virtuellen Maschinen auf und fügen Sie eine Netzwerkverbindung mit dem internen Netzwerk als Verbindungsmethode hinzu. Der Screenshot sieht wie folgt aus (die beiden virtuellen Maschinen haben dieselbe Konfiguration):

Internes Netzwerk

Melden Sie sich beim virtuellen Maschinensystem an und verwenden Sie den Befehl „ip addr“, um die aktuellen Netzwerkverbindungsinformationen anzuzeigen:

$ IP-Adresse
...
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel Status UP-Gruppe Standard qlen 1000
 Link/Ether 08:00:27:38:65:a8 brd ff:ff:ff:ff:ff:ff:ff
 inet 10.0.2.15/24 brd 10.0.2.255 Bereich global dynamisch noprefixroute enp0s3
  valid_lft 86390 Sek. bevorzugt_lft 86390 Sek.
 inet6 fe80::9a49:54d3:2ea6:1b50/64 Bereichslink kein Präfix
  valid_lft für immer preferred_lft für immer
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel Status UP-Gruppe Standard qlen 1000
 link/ether 08:00:27:0d:0b:de brd ff:ff:ff:ff:ff:ff
 inet6 fe80::2329:85bd:937e:c484/64 Bereichslink noprefixroute
  valid_lft für immer preferred_lft für immer

Es ist ersichtlich, dass die Netzwerkkarte enp0s8 noch nicht an eine IPv4-Adresse gebunden ist und ihr manuell eine statische IP zugewiesen werden muss.

Es ist zu beachten, dass ab Ubuntu 17.10 ein neues Tool namens Netplan eingeführt wurde und die ursprüngliche /etc/network/interfaces nicht mehr wirksam ist.

Wenn Sie eine statische IP für die Netzwerkkarte festlegen, müssen Sie daher die Konfigurationsdatei /etc/netplan/01-network-manager-all.yaml ändern. Das Beispiel lautet wie folgt:

Netzwerk:
 Version: 2
 Renderer: NetworkManager
  Ethernets:
  enp0s8:
   dhcp4: nein
   dhcp6: nein
   Adressen: [192.168.1.101/24]
# Gateway4: 192.168.1.101
# Nameserver:
# Adressen: [192.168.1.101, 8.8.8.8]

Da sich die beiden Hosts im selben Subnetz befinden, können sie auch dann aufeinander zugreifen, wenn Gateway und DNS-Server nicht konfiguriert sind. Kommentieren Sie vorerst die entsprechenden Konfigurationselemente aus (Sie können später versuchen, Ihren eigenen DNS-Server zu erstellen).

Führen Sie nach der Bearbeitung den Befehl sudo netplan apply aus und die zuvor konfigurierte statische IP wird wirksam.

$ IP-Adresse
...
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel Status UP-Gruppe Standard qlen 1000
  link/ether 08:00:27:0d:0b:de brd ff:ff:ff:ff:ff:ff
  inet 192.168.1.101/24 brd 192.168.1.255 Bereich global noprefixroute enp0s8
    valid_lft für immer preferred_lft für immer
  inet6 fe80::a00:27ff:fe0d:bde/64 Bereichslink
    valid_lft für immer preferred_lft für immer

Melden Sie sich bei einer anderen virtuellen Maschine an und führen Sie denselben Vorgang aus (beachten Sie, dass das Adresselement in der Konfigurationsdatei in [192.168.1.102/24] geändert wird). Die Netzwerkkonfiguration der beiden virtuellen Maschinen ist abgeschlossen.

Derzeit gibt es einen virtuellen Linux-Computerserver1 mit der IP-Adresse 192.168.1.101 und einen virtuellen Linux-Computerserver2 mit der IP-Adresse 192.168.1.102. Die beiden Hosts können aufeinander zugreifen. Der Test läuft wie folgt ab:

starky@server1:~$ ping 192.168.1.102 -c 2
PING 192.168.1.102 (192.168.1.102) 56(84) Bytes Daten.
64 Bytes von 192.168.1.102: icmp_seq=1 ttl=64 Zeit=0,951 ms
64 Bytes von 192.168.1.102: icmp_seq=2 ttl=64 Zeit=0,330 ms
--- 192.168.1.102 Ping-Statistiken ---
2 Pakete gesendet, 2 empfangen, 0 % Paketverlust, Zeit 2 ms
RTT min./avg./max./mdev = 0,330/0,640/0,951/0,311 ms
skitar@server2:~$ ping 192.168.1.101 -c 2
PING 192.168.1.101 (192.168.1.101) 56(84) Bytes Daten.
64 Bytes von 192.168.1.101: icmp_seq=1 ttl=64 Zeit=0,223 ms
64 Bytes von 192.168.1.101: icmp_seq=2 ttl=64 Zeit=0,249 ms
--- 192.168.1.101 Ping-Statistiken ---
2 Pakete gesendet, 2 empfangen, 0 % Paketverlust, Zeit 29 ms
RTT min./avg./max./mdev. = 0,223/0,236/0,249/0,013 ms

2. Installieren Sie den Nginx-Server

Es gibt zwei Hauptmöglichkeiten, Nginx zu installieren:

• Vorkompilierte Binärdateien. Dies ist die einfachste und schnellste Installationsmethode. Alle gängigen Betriebssysteme können es über Paketmanager installieren (wie etwa apt-get in Ubuntu). Mit dieser Methode werden fast alle offiziellen Module oder Plugins installiert.
  
• Aus dem Quellcode kompilieren und installieren. Diese Methode ist flexibler als die vorherige und Sie können die Module oder Plug-Ins von Drittanbietern auswählen, die Sie installieren möchten.
  

Dieses Beispiel stellt keine besonderen Anforderungen, wählen Sie daher direkt die erste Installationsmethode. Der Befehl lautet wie folgt:

$ sudo apt-get update
$ sudo apt-get installiere nginx

Verwenden Sie nach erfolgreicher Installation systemctl status nginx , um den Laufstatus des Nginx-Dienstes anzuzeigen:

$ systemctl status nginx
● nginx.service – Ein Hochleistungs-Webserver und ein Reverse-Proxy-Server
  Geladen: geladen (/lib/systemd/system/nginx.service; aktiviert; Vendor-Vorgabe: en
  Aktiv: aktiv (läuft) seit Dienstag, 02.07.2019, 01:22:07 CST; vor 26 Sek.
   Dokumentation: man:nginx(8)
 Haupt-PID: 3748 (nginx)
  Aufgaben: 2 (Limit: 1092)
  Speicher: 4,9 M
  CGroup: /system.slice/nginx.service
      ├─3748 nginx: Masterprozess /usr/sbin/nginx -g Daemon ein; master_pro
      └─3749 nginx: Arbeitsprozess

Verwenden Sie den Befehl curl -I 127.0.0.1 um zu überprüfen, ob auf den Webserver normal zugegriffen werden kann:

$ curl -I 127.0.0.1
HTTP/1.1 200 OK
Server: nginx/1.15.9 (Ubuntu)
...

3. Lastenausgleichskonfiguration

Beim Lastenausgleich wird die Last nach bestimmten Regeln auf mehrere Betriebseinheiten verteilt und dadurch die Verfügbarkeit und Reaktionsgeschwindigkeit des Dienstes verbessert.

Ein einfaches Beispieldiagramm sieht wie folgt aus:

Lastverteilung

Wenn beispielsweise eine Website-Anwendung auf einem Servercluster bereitgestellt wird, der aus mehreren Hosts besteht, befindet sich der Lastausgleichsserver zwischen dem Terminalbenutzer und dem Servercluster. Er ist dafür verantwortlich, den Zugriffsverkehr des Terminalbenutzers zu empfangen und den Benutzerzugriff gemäß bestimmten Regeln auf den Back-End-Serverhost zu verteilen, wodurch die Reaktionsgeschwindigkeit bei hoher Parallelität verbessert wird.

Lastenausgleichsserver

Nginx kann den Lastenausgleich über die Upstream-Option konfigurieren. Hier wird die virtuelle Maschine Server1 als Lastausgleichsserver verwendet.

Ändern Sie die Standard-Site-Konfigurationsdatei auf Server1 ( sudo vim /etc/nginx/sites-available/default ) mit dem folgenden Inhalt:

Upstream-Backend {
  Server 192.168.1.102:8000;
  Server 192.168.1.102;
}
Server {
  hören Sie 80;

  Standort / {
    Proxy-Passwort http://backend;
  }
}

Zu Testzwecken stehen aktuell nur zwei virtuelle Maschinen zur Verfügung. Server1 (192.168.1.101) wird bereits als Lastausgleichsserver verwendet, verwenden Sie daher Server2 (192.168.1.102) als Anwendungsserver.

Hierbei werden mit Hilfe der Virtual Host Funktion von nginx 192.168.1.102 und 192.168.1.102:8000 als zwei unterschiedliche Anwendungsserver „simuliert“.

Anwendungsserver

Ändern Sie die Standard-Site-Konfigurationsdatei auf Server2 ( sudo vim /etc/nginx/sites-available/default ) mit dem folgenden Inhalt:

Server {
    hören Sie 80;

    Wurzel /var/www/html;

    index index.html index.htm index.nginx-debian.html;

    Servername 192.168.1.102;

    Standort / {
        versuche_dateien $uri $uri/ =404;
    }
}

Erstellen Sie eine Datei index.html im Verzeichnis /var/www/html als Indexseite der Standardsite. Der Inhalt ist wie folgt:

<html>
  <Kopf>
    <title>Indexseite von Server1</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server1, Adresse 192.168.1.102.</h1>
  </body>
</html>

Führen Sie den Befehl sudo systemctl restart nginx aus, um den nginx-Dienst neu zu starten. Besuchen Sie nun http://192.168.1.102, um die soeben erstellte Seite index.html aufzurufen:

$ locken 192.168.1.102
<html>
  <Kopf>
    <title>Indexseite von Server1</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server1, Adresse 192.168.1.102.</h1>
  </body>
</html>

Konfigurieren Sie die Site auf „einem anderen Host“ und erstellen Sie die Konfigurationsdatei /etc/nginx/sites-available/server2 auf Server2 mit folgendem Inhalt:

Server {
    hör zu 8000;

    Wurzel /var/www/html;

    index index2.html index.htm index.nginx-debian.html;

    Servername 192.168.1.102;

    Standort / {
        versuche_dateien $uri $uri/ =404;
    }
}

Beachten Sie die Änderungen im Abhörport und in der Indexseitenkonfiguration. Erstellen Sie die Datei index2.html im Verzeichnis /var/www/html als Indexseite der Site server2. Der Inhalt ist wie folgt:

<html>
  <Kopf>
    <title>Indexseite von Server2</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server2, Adresse 192.168.1.102:8000.</h1>
  </body>
</html>

PS: Zu Testzwecken sind die Standardsite und die Server2-Site auf demselben Host Server2 konfiguriert und die Seiten unterscheiden sich geringfügig. In tatsächlichen Umgebungen sind diese beiden Sites normalerweise auf verschiedenen Hosts mit demselben Inhalt konfiguriert.

Führen Sie sudo ln -s /etc/nginx/sites-available/server2 /etc/nginx/sites-enabled/ um die gerade erstellte Server2-Site zu aktivieren.

Starten Sie den nginx-Dienst neu. Besuchen Sie nun http://192.168.1.102:8000, um die soeben erstellte Seite index2.html aufzurufen:

$ locken 192.168.1.102:8000
<html>
  <Kopf>
    <title>Indexseite von Server2</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server2, Adresse 192.168.1.102:8000.</h1>
  </body>
</html>

Lastausgleichstest

Zurück zum Lastausgleichsserver, der virtuellen Maschine Server1. Die in seiner Konfigurationsdatei festgelegte Reverse-Proxy-URL lautet http://backend.

Da der Domänennamenauflösungsdienst nicht konfiguriert wurde, kann die URL http://backend nicht an der richtigen Stelle gefunden werden.

Sie können die Datei /etc/hosts auf Server1 ändern und den folgenden Datensatz hinzufügen:

127.0.0.1 Backend

Der Domänenname kann in die lokale IP aufgelöst werden, um den Zugriff auf den Lastausgleichsserver abzuschließen.

Starten Sie den nginx-Dienst neu und greifen Sie auf http://backend auf Server1 zu. Die Ergebnisse sind wie folgt:

$ curl http://backend
<html>
  <Kopf>
    <title>Indexseite von Server1</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server1, Adresse 192.168.1.102.</h1>
  </body>
</html>
$ curl http://backend
<html>
  <Kopf>
    <title>Indexseite von Server2</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server2, Adresse 192.168.1.102:8000.</h1>
  </body>
</html>
$ curl http://backend
<html>
  <Kopf>
    <title>Indexseite von Server1</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server1, Adresse 192.168.1.102.</h1>
  </body>
</html>
$ curl http://backend
<html>
  <Kopf>
    <title>Indexseite von Server2</title>
  </Kopf>
  <Text>
    <h1>Dies ist Server2, Adresse 192.168.1.102:8000.</h1>
  </body>
</html>

Aus der Ausgabe können wir ersehen, dass der Zugriff von Server1 auf den Lastausgleichsserver http://backend die Abfrage der beiden Websites auf dem Anwendungsserver Server2 abschließt und somit eine Rolle beim Lastausgleich spielt.

4. Methoden zum Lastenausgleich

Die Open-Source-Version von Nginx bietet vier Implementierungsmethoden für den Lastausgleich, die im Folgenden kurz vorgestellt werden.

1. Rundenturnier

Benutzeranfragen werden gleichmäßig auf den Backend-Servercluster verteilt (die Gewichtung der Abfrage kann über die Option „weight“ festgelegt werden). Dies ist die von nginx verwendete Standardmethode zum Lastenausgleich:

Upstream-Backend {
  Server backend1.example.com Gewicht=5;
  Server backend2.example.com;
}

2. Wenigste Verbindungen

Benutzeranforderungen werden an den Server mit der geringsten Anzahl aktiver Verbindungen im Cluster weitergeleitet. Die Gewichtsoption wird ebenfalls unterstützt.

Upstream-Backend {
  am wenigsten_Verbindung;
  Server backend1.example.com;
  Server backend2.example.com;
}

3. IP-Hash

Benutzeranfragen werden basierend auf der Client-IP-Adresse weitergeleitet. Das heißt, diese Methode soll sicherstellen, dass ein bestimmter Client letztendlich auf denselben Server-Host zugreift.

Upstream-Backend {
  ip_hash;
  Server backend1.example.com;
  Server backend2.example.com;
}

4. Generischer Hash

Die Benutzeranforderung bestimmt das endgültige Weiterleitungsziel basierend auf einem benutzerdefinierten Schlüsselwert, der eine Zeichenfolge, eine Variable oder eine Kombination (z. B. Quell-IP und Portnummer) sein kann.

Upstream-Backend {
  Hash $request_uri konsistent;
  Server backend1.example.com;
  Server backend2.example.com;
}

Gewicht

Siehe die folgende Beispielkonfiguration:

Upstream-Backend {
  Server backend1.example.com Gewicht=5;
  Server backend2.example.com;
  Server 192.0.0.1-Sicherung;
}

Das Standardgewicht ist 1. Der Backup-Server akzeptiert Anfragen nur, wenn alle anderen Server ausgefallen sind.

Im obigen Beispiel werden von jeweils 6 Anfragen 5 an backend1.example.com und 1 an backend2.example.com weitergeleitet. Nur wenn Backend1 und Backend2 beide ausgefallen sind, empfängt und verarbeitet 192.0.0.1 die Anforderung.

Verweise

HTTP-Lastenausgleich

Zusammenfassen

Oben finden Sie eine ausführliche Erklärung des Herausgebers zur Installation des Linux-Systems Nginx-Server und zur Konfiguration des Lastenausgleichs. Ich hoffe, dass sie für alle hilfreich ist. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Herausgeber wird Ihnen rechtzeitig antworten. Ich möchte auch allen für ihre Unterstützung der Website 123WORDPRESS.COM danken!
Wenn Sie diesen Artikel hilfreich finden, können Sie ihn gerne abdrucken und dabei bitte die Quelle angeben. Vielen Dank!