NGINX ist ein konsolidierter Open-Source-, Hochleistungs-Webserver, der die Bereitstellung von Inhalten und Anwendungen beschleunigt, die Sicherheit verbessert und die Skalierbarkeit erhöht. Einer der häufigsten Anwendungsfälle von Nginx ist das Inhalts-Caching, was der effektivste Weg ist, um die Leistung einer Website zu verbessern.
Mehr lesen: 10 Top Open Source Caching Tools für Linux
Sie können NGINX verwenden, um lokale Ursprungsserver zu beschleunigen, indem Sie es so konfigurieren, dass es Antworten von Upstream-Servern zwischenspeichert, und auch um Edge-Server für Content-Delivery-Netzwerke (CDNs) zu erstellen. NGINX ist die Grundlage einiger der größten CDNs.
Bei Konfiguration als Cache wird NGINX folgendes tun:
- statischen und dynamischen Inhalt zwischenspeichern.
- die Leistung von dynamischem Inhalt mit Mikro-Caching verbessern.
- veralteten Inhalt bereitstellen, während im Hintergrund eine Neuprüfung für bessere Leistung stattfindet.
- Cache-Control-Header überschreiben oder setzen und mehr.
In diesem Artikel erfahren Sie, wie Sie NGINX als Inhalts-Caching unter Linux konfigurieren, um Ihre Webserver so effizient wie möglich zu betreiben.
Voraussetzungen:
Sie sollten NGINX auf Ihrem Linux-Server installiert haben. Wenn nicht, folgen Sie diesen Anleitungen zur Installation von Nginx:
Statische Inhalte im Nginx cachen
Statische Inhalte sind Inhalte einer Webseite, die auf allen Seiten gleich bleiben (nicht ändern). Beispiele für statische Inhalte sind Dateien wie Bilder, Videos, Dokumente; CSS-Dateien und JavaScript-Dateien.
Wenn Ihre Webseite viel statischen Inhalt verwendet, können Sie das Performanceoptimieren aktivieren, indem Sie Client-seitiges Caching aktivieren, bei dem der Browser Kopien von statischen Inhalten speichert, um schneller zugreifen zu können.
Die folgende Testkonfiguration ist eine gute Vorgehensweise, nur ersetzen Sie www.example.com mit dem URL Ihrer Webseite und passen Sie andere Pfadnamen entsprechend an.
server {
# substitute your web server's URL for www.example.com
server_name www.example.com;
root /var/www/example.com/htdocs;
index index.php;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ .php$ {
try_files $uri =404;
include fastcgi_params;
# substitute the socket, or address and port, of your WordPress server
fastcgi_pass unix:/var/run/php5-fpm.sock;
#fastcgi_pass 127.0.0.1:9000;
}
location ~* .(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|css|rss|atom|js|jpg
|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid
|midi|wav|bmp|rtf)$ {
expires max;
log_not_found off;
access_log off;
}
}
Dynamischen Inhalt im Nginx cachen
NGINX verwendet ein persistentes Laufwerkbasiertes Cache, das irgendwo im lokalen Dateisystem liegt. Starten Sie daher mit der Erstellung des lokalen Laufwerkverzeichnisses, das zum Speichern von zwischengespeicherten Inhalten genutzt wird.
# mkdir -p /var/cache/nginx
Weiterhin setzen Sie die passende Eigentumsrechte auf dem Cacheverzeichnis. Es sollte dem NGINX-Benutzer (nginx) und der Gruppe (nginx) gehören. Fahren Sie mit dem Weiterlesen fort, um zu sehen, wie Sie dynamischen Inhalt in Nginx aktivieren können.
# chown nginx:nginx /var/cache/nginx
Jetzt gehen Sie weiter, um zu sehen, wie Sie im folgenden Abschnitt das schnelle CGI-Cache in NGINX aktivieren können.
Aktivieren des FastCGI-Caches in NGINX
FastCGI (oder FCGI) ist ein weit verbreitetes Protokoll zur Schnittstellensteuerung interaktiver Anwendungen wie PHP mit Webservern wie NGINX. Es handelt sich um eine Erweiterung der CGI (Common Gateway Interface).
Der Hauptvorteil von FCGI besteht darin, dass es mehrere CGI-Anfragen in einem einzigen Prozess verwaltet. Ohne dies müsste der Webserver für jeden Client-Anfrage einen neuen Prozess öffnen (der gesteuert, eine Anfrage verarbeiten und geschlossen werden muss), um einen Dienst bereitzustellen.
Zur Verarbeitung von PHP-Skripten in einer LEMP-Stack-Bereitstellung verwendet NGINX FPM (FastCGI Process Manager) oder PHP-FPM, eine beliebte alternative PHP FastCGI-Implementierung. Sobald der PHP-FPM-Prozess läuft, ist NGINX so konfiguriert, dass Anfragen zur Verarbeitung an ihn weitergeleitet werden. Dadurch kann NGINX auch so konfiguriert werden, dass Antworten vom Backend-Anwendungsserver PHP-FPM zwischengespeichert werden.
Unter NGINX wird der FastCGI-Inhalts-Cache mit einer Direktive namens fastcgi_cache_path im obersten http{}-Kontext innerhalb der NGINX-Konfigurationsstruktur deklariert. Sie können auch den fastcgi_cache_key hinzufügen, der einen Schlüssel (Anfragekennung) für die Zwischenspeicherung definiert.
Außerdem fügen Sie die Direktive add_header X-Cache-Status innerhalb des http{}-Kontexts hinzu – dies ist nützlich für Debugging-Zwecke.
Angenommen, die Konfigurationsdatei des Serverblocks Ihrer Website befindet sich unter /etc/nginx/conf.d/testapp.conf oder /etc/nginx/sites-available/testapp.conf (unter Ubuntu und seinen Derivaten), öffnen Sie die Datei zur Bearbeitung und fügen Sie die folgenden Zeilen oben in die Datei ein.
fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=CACHEZONE:10m; inactive=60m max_size=40m; fastcgi_cache_key "$scheme$request_method$host$request_uri"; add_header X-Cache $upstream_cache_status;
Die Direktive fastcgi_cache_path legt die Anzahl der Parameter fest, die wie folgt sind:
- /var/cache/nginx – der Pfad zum lokalen Verzeichnis auf der Festplatte für den Cache.
- levels – definiert die Hierarchieebenen eines Caches, es wird eine zweistufige Verzeichnishierarchie unter /var/cache/nginx eingerichtet.
- keys_zone (name:size) – ermöglicht die Erstellung einer gemeinsamen Speicherzone, in der alle aktiven Schlüssel und Informationen über Daten (Metadaten) gespeichert werden. Beachten Sie, dass das Speichern der Schlüssel im Arbeitsspeicher den Überprüfungsprozess beschleunigt, indem es für NGINX einfacher wird festzustellen, ob es sich um einen MISS oder HIT handelt, ohne den Status auf der Festplatte zu überprüfen.
- inactive – legt fest, nach welcher Zeitspanne zwischengespeicherte Daten, die während der angegebenen Zeit nicht abgerufen werden, unabhängig von ihrer Aktualität aus dem Cache gelöscht werden. Ein Wert von 60m in unserer Beispielkonfiguration bedeutet, dass Dateien, die nach 60 Minuten nicht abgerufen wurden, aus dem Cache entfernt werden.
- max_size – gibt die maximale Größe des Caches an. Hier können weitere Parameter verwendet werden (lesen Sie die NGINX-Dokumentation für weitere Informationen).
Die Variablen in der Anweisung fastcgi_cache_key werden unten beschrieben.
NGINX verwendet sie zur Berechnung des Schlüssels (Identifikator) einer Anfrage. Wichtig ist, dass eine zwischengespeicherte Antwort an den Client gesendet werden kann, wenn die Anfrage den gleichen Schlüssel wie eine zwischengespeicherte Antwort hat.
- $scheme – Anfrageschema, HTTP oder HTTPS.
- $request_method – Anfragemethode, normalerweise „GET“ oder „POST“.
- $host – dies kann der Hostname aus der Anforderungszeile oder der Hostname aus dem „Host“ Anforderungskopffeld oder der Servername sein, der mit einer Anfrage übereinstimmt, in der Reihenfolge der Priorität.
- $request_uri – bedeutet die vollständige ursprüngliche Anforderungs-URI (mit Argumenten).
Außerdem wird die Variable $upstream_cache_status in der Anweisung add_header X-Cache-Status für jede Anfrage berechnet, auf die NGINX antwortet, unabhängig davon, ob es sich um ein MISS (Antwort im Cache nicht gefunden, vom Anwendungsserver erhalten) oder ein HIT (Antwort aus dem Cache bereitgestellt) oder einen der anderen unterstützten Werte handelt.
Dann verwendet die location Anweisung, die PHP-Anfragen an PHP-FPM weiterleitet, die fastcgi_cache Anweisungen, um den gerade definierten Cache zu aktivieren.
Legen Sie auch die Cache-Zeit für verschiedene Antworten mit der Anweisung fastcgi_cache_valid fest, wie gezeigt.
fastcgi_cache CACHEZONE; fastcgi_cache_valid 60m;
Wenn nur die Zwischenspeicherzeit angegeben ist, wie in unserem Fall, werden nur 200, 301 und 302 Antworten zwischengespeichert. Sie können jedoch auch die Antworten explizit angeben oder beliebige (für beliebigen Antwortcode) verwenden:
fastcgi_cache CACHEZONE; fastcgi_cache_valid 200 301 203 60m; fastcgi_cache_valid 404 10m; OR fastcgi_cache CACHEZONE; fastcgi_cache_valid any 10m;
Feinabstimmung der FastCGI-Caching-Performance auf Nginx
Um die minimale Anzahl von Anfragen mit demselben Schlüssel festzulegen, die gestellt werden müssen, bevor die Antwort zwischengespeichert wird, fügen Sie die Anweisung fastcgi_cache_min_uses in den http{}-, server{}– oder location{}-Kontext ein.
fastcgi_cache_min_uses 3
Um die Überprüfung abgelaufener Zwischenspeichereinträge mit bedingten Anfragen unter Verwendung der Headerfelder „If-Modified-Since“ und „If-None-Match“ zu aktivieren, fügen Sie die Anweisung fastcgi_cache_revalidate in den http{}-, server{}– oder location{}-Kontext ein.
fastcgi_cache_revalidate on;
Sie können auch NGINX anweisen, zwischengespeicherten Inhalt auszuliefern, wenn der Ursprungsserver oder der FCGI-Server nicht erreichbar ist, indem Sie die Anweisung proxy_cache_use_stale innerhalb der location-Anweisung verwenden.
Diese Beispieleinstellung bedeutet, dass wenn NGINX einen Fehler, eine Zeitüberschreitung oder einen der angegebenen Fehler vom Upstream-Server empfängt und eine veraltete Version der angeforderten Datei im zwischengespeicherten Inhalt hat, liefert es die veraltete Datei aus.
proxy_cache_use_stale error timeout http_500;
Eine weitere nützliche Anweisung zur Feinabstimmung der FCGI-Caching-Performance ist fastcgi_cache_background_update, die in Verbindung mit der Anweisung proxy_cache_use_stale funktioniert. Wenn sie auf „on“ gesetzt ist, weist sie NGINX an, veraltete Inhalte zu servieren, wenn Clients nach einer Datei fragen, die abgelaufen ist oder gerade aktualisiert wird.
fastcgi_cache_background_update on;
Auch fastcgi_cache_lock ist nützlich zur Feinabstimmung der Cache-Performance. Wenn mehrere Clients nach demselben Inhalt fragen, der nicht im Cache vorhanden ist, leitet NGINX nur die erste Anfrage an den Upstream-Server weiter, speichert die Antwort im Cache und bedient die anderen Client-Anfragen aus dem Cache.
fastcgi_cache_lock on;
Nachdem Sie alle oben genannten Änderungen in der Konfigurationsdatei von NGINX vorgenommen haben, speichern und schließen Sie sie. Überprüfen Sie dann die Konfigurationsstruktur auf Syntaxfehler, bevor Sie den NGINX-Dienst neu starten.
# nginx -t # systemctl restart nginx
Als nächstes testen Sie, ob der Cache ordnungsgemäß funktioniert, indem Sie versuchen, auf Ihre Webanwendung oder Website mit dem folgenden curl-Befehl zuzugreifen (beim ersten Mal sollte ein MISS angezeigt werden, aber nachfolgende Anfragen sollten einen HIT anzeigen, wie im Screenshot gezeigt).
# curl -I http://testapp.tecmint.com
Hier ist ein weiterer Screenshot, der zeigt, wie NGINX veraltete Daten serviert.
Hinzufügen von Ausnahmen, um den Cache zu umgehen.
Es ist möglich, Bedingungen festzulegen, unter denen NGINX mit der Direktive fastcgi_cache_bypass keine zwischengespeicherten Antworten an Clients senden soll. Um NGINX anzuweisen, überhaupt keine Antworten vom Upstream-Server zu zwischenspeichern, verwenden Sie die Direktive fastcgi_no_cache.
Zum Beispiel, wenn Sie möchten, dass POST Anfragen und URLs mit einer Query-String immer an PHP gesendet werden. Erstellen Sie zunächst eine if-Anweisung, um die Bedingung festzulegen, wie folgt.
set $skip_cache 0;
if ($request_method = POST) {
set $skip_cache 1;
}
Aktivieren Sie dann die oben genannte Ausnahme in der location-Direktive, die PHP-Anfragen an PHP-FPM weiterleitet, indem Sie die Direktiven fastcgi_cache_bypass und fastcgi_no_cache verwenden.
fastcgi_cache_bypass $skip_cache; fastcgi_no_cache $skip_cache;
Es gibt viele andere Teile Ihrer Website, für die Sie möglicherweise keine Inhaltszwischenspeicherung aktivieren möchten. Die folgende Beispielkonfiguration von NGINX verbessert die Leistung einer WordPress-Website und stammt aus dem Blog nginx.com.
Um sie zu verwenden, ändern Sie die Einstellungen (wie Domain, Pfade, Dateinamen usw.), um Ihre Umgebung widerzuspiegeln.
fastcgi_cache_path /var/run/NGINX-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
server {
server_name example.com www.example.com;
root /var/www/example.com;
index index.php;
access_log /var/log/NGINX/example.com.access.log;
error_log /var/log/NGINX/example.com.error.log;
set $skip_cache 0;
# POST requests and URLs with a query string should always go to PHP
if ($request_method = POST) {
set $skip_cache 1;
}
if ($query_string != "") {
set $skip_cache 1;
}
# Don't cache URIs containing the following segments
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/feed/|index.php |sitemap(_index)?.xml") {
set $skip_cache 1;
}
# Don't use the cache for logged-in users or recent commenters
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass |wordpress_no_cache|wordpress_logged_in") {
set $skip_cache 1;
}
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ .php$ {
try_files $uri /index.php;
include fastcgi_params;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_cache_bypass $skip_cache;
fastcgi_no_cache $skip_cache;
fastcgi_cache WORDPRESS;
fastcgi_cache_valid 60m;
}
location ~ /purge(/.*) {
fastcgi_cache_purge WORDPRESS "$scheme$request_method$host$1";
}
location ~* ^.+.(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|css|rss|atom|js|jpg|jpeg |gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi |wav|bmp|rtf)$ {
access_log off;
log_not_found off;
expires max;
}
location = /robots.txt {
access_log off;
log_not_found off;
}
location ~ /. {
deny all;
access_log off;
log_not_found off;
}
}
Aktivieren des Proxy-Caches in NGINX
NGINX unterstützt auch das Zwischenspeichern von Antworten anderer Proxy-Server (definiert durch die Direktive proxy_pass). In diesem Testfall verwenden wir NGINX als Reverse-Proxy für eine Node.js-Webanwendung, daher werden wir NGINX als Cache für die Node.js-Anwendung aktivieren. Alle hier verwendeten Konfigurationsdirektiven haben ähnliche Bedeutungen wie die FastCGI-Direktiven im vorherigen Abschnitt, daher werden wir sie nicht erneut erläutern.
Um die Zwischenspeicherung von Antworten eines durch einen Proxy geleiteten Servers zu aktivieren, sollten Sie die Direktive proxy_cache_path im obersten Level des http{} Kontextes einbeziehen. Um zu bestimmen, wie Anfragen zwischengespeichert werden, können Sie auch die Direktive proxy_cache_key hinzufügen, wie folgt.
proxy_cache_path /var/cache/nginx app1 keys_zone=PROXYCACHE:100m inactive=60m max_size=500m; proxy_cache_key "$scheme$request_method$host$request_uri"; add_header X-Cache-Status $upstream_cache_status; proxy_cache_min_uses 3;
Weiterhin sollten Sie den Zwischenspeicher im Ortungsdirektiv aktivieren.
location / {
proxy_pass http://127.0.0.1:3000;
proxy_cache PROXYCACHE;
proxy_cache_valid 200 302 10m;
proxy_cache_valid 404 1m;
}
Um zu definieren, unter welchen Bedingungen NGINX keinen zwischengespeicherten Inhalt sendet und keine Antwort vom Upstream-Server zwischen speichert, sollten Sie die Direktiven proxy_cache_bypass und proxy_no_cache aufnehmen.
proxy_cache_bypass $cookie_nocache $arg_nocache$arg_comment; proxy_no_cache $http_pragma $http_authorization;
Feineinstellung der Leistung des Proxy-Zwischenspeichers
Die folgenden Direktiven sind nützlich für die Feineinstellung der Leistung des Proxy-Zwischenspeichers. Sie haben auch die gleichen Bedeutungen wie die FastCGI-Direktiven.
proxy_cache_min_uses 3; proxy_cache_revalidate on; proxy_cache_use_stale error timeout updating http_500; proxy_cache_background_update on; proxy_cache_lock on;
Weitere Informationen und Konfigurationsdirektiven für Zwischenspeicherung finden Sie in der Dokumentation der beiden Hauptmodule ngx_http_fastcgi_module und ngx_http_proxy_module.
Zusätzliche Ressourcen: NGINX-Inhaltszwischenspeicherung und Tips for Improving WordPress Performance.