Wéi Cache Inhalt an NGINX
NGINX ass e konsolidéierten Open-Source, High-Performance Webserver deen Inhalt an Uwendungsliwwerung beschleunegt, d'Sécherheet verbessert an d'Skalierbarkeet verbessert. Ee vun den heefegste Benotzungsfäll vun Nginx ass e Content Caching, deen den effektivste Wee ass fir d'Performance vun enger Websäit ze stäerken.
Dir kënnt NGINX benotzen fir lokal Origine Serveren ze beschleunegen andeems Dir se konfiguréiert fir Äntwerte vun Upstream Serveren ze cache an och Randservere fir Inhalt Liwwerungsnetzwierker (CDNs) ze kreéieren. NGINX Kraaft e puer vun de gréisste CDNs.
Wann als Cache konfiguréiert ass, wäert NGINX:
- Cache statesch an dynameschen Inhalt.
- verbessert dynamesch Inhaltsleeschtung mat Mikro-Caching.
- Dervéiert alen Inhalt wärend Dir am Hannergrond revalidéiert fir besser Leeschtung.
- iwwerschreiden oder setzen Cache-Control Header, a méi.
An dësem Artikel léiert Dir wéi Dir NGINX als Content Caching an Linux konfiguréiert fir Är Webserver esou effizient wéi méiglech ze maachen.
Dir sollt NGINX op Ärem Linux Server installéiert hunn, wann net dës Guiden befollegen fir Nginx z'installéieren:
- Wéi installéiere ech Nginx op CentOS 8
- Wéi installéiere ech Nginx op CentOS 7
Cache statesche Inhalt op Nginx
Statesche Inhalt ass Inhalt vun enger Websäit déi d'selwecht bleift (ännert sech net) iwwer Säiten. Beispiller vu statesche Inhalt enthalen Dateie wéi Biller, Videoen, Dokumenter; CSS Dateien, a JavaScript Dateien.
Wann Är Websäit vill statesch Inhalter benotzt, da kënnt Dir seng Leeschtung optimiséieren andeems Dir Client-Säit Caching aktivéiert, wou de Browser Kopien vum statesche Inhalt fir méi séier Zougang späichert.
Déi folgend Proufkonfiguratioun ass gutt, ersetzt just www.example.com duerch d'URL vun Ärem Websäitnumm a maacht Ännerunge fir aner Pathnimm wéi passend.
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;
}
}
Cache Dynamic Inhalt op Nginx
NGINX benotzt e persistent Disk-baséiert Cache deen iergendwou am lokalen Dateiesystem läit. Also fänkt un mat der Erstellung vum lokalen Diskverzeechnes fir den cachege Inhalt ze späicheren.
# mkdir -p /var/cache/nginx
Als nächst setzt de passenden Eegentum am Cache Verzeichnis. Et sollt am Besëtz vum NGINX Benotzer (nginx) a Grupp (nginx) wéi follegt sinn.
# chown nginx:nginx /var/cache/nginx
Elo fuert weider fir ze kucken wéi dynamesch Inhalter op Nginx an der ënnen Sektioun aktivéiert ginn.
FastCGI Cache an NGINX aktivéieren
FastCGI (oder FCGI) ass e wäit benotzte Protokoll fir interaktiv Uwendungen wéi PHP mat Webserver wéi NGINX ze interfacéieren. Et ass eng Extensioun vum CGI (Common Gateway Interface).
Den Haaptvirdeel vum FCGI ass datt et verschidde CGI Ufroen an engem eenzege Prozess geréiert. Ouni et muss de Webserver en neie Prozess opmaachen (dee muss kontrolléiert ginn, eng Ufro veraarbecht ginn an zougemaach ginn) fir all Client Ufro fir e Service.
Fir PHP Scripten an engem LEMP Stack Deployment ze veraarbechten, benotzt NGINX FPM (FastCGI Process Manager) oder PHP-FPM, eng populär Alternativ PHP FastCGI Implementatioun. Wann de PHP-FPM Prozess leeft, ass NGINX konfiguréiert fir Proxy Ufroe fir d'Veraarbechtung. Also kann NGINX och konfiguréiert ginn fir Äntwerte vum PHP-FPM Backend Applikatiounsserver ze cache.
Ënner NGINX gëtt de FastCGI Inhalt Cache deklaréiert mat enger Direktiv mam Numm fastcgi_cache_path am Top-Level http{} Kontext, bannent der NGINX Konfiguratiounsstruktur. Dir kënnt och de fastcgi_cache_key derbäisetzen, deen e Schlëssel (Ufro Identifizéierer) fir Cache definéiert.
Ausserdeem, fir den Upstream-Cache-Status ze liesen, füügt d'add_header X-Cache-Status Direktiv am http{} Kontext bäi - dëst ass nëtzlech fir Debuggingzwecker.
Ugeholl datt d'Serverblockkonfiguratiounsdatei vun Ärem Site um /etc/nginx/conf.d/testapp.conf oder /etc/nginx/sites-available/testapp.conf (ënner Ubuntu a sengen Derivate) läit, öffnen d'Editiounsdatei op a füügt derbäi déi folgend Zeilen um Top vun der Datei.
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;
D'fastcgi_cache_path Direktiv spezifizéiert d'Zuel vun de Parameteren déi sinn:
- /var/cache/nginx - de Wee zum lokalen Disk Verzeechnes fir de Cache.
- Niveauen - definéiert d'Hierarchieniveauen vun engem Cache, et setzt eng Zwee-Niveau Verzeichnishierarchie ënner /var/cache/nginx op.
- Keys_zone (Numm: Gréisst) - erméiglecht d'Schafung vun enger gemeinsamer Erënnerungszone wou all aktiv Schlësselen an Informatioun iwwer Daten (Meta) gespäichert sinn. Notéiert datt d'Späichere vun de Schlësselen an der Erënnerung de Kontrollprozess beschleunegt, andeems et NGINX méi einfach gëtt fir ze bestëmmen ob et e MISS oder HIT ass, ouni de Status op der Disk ze kontrolléieren.
- inaktiv - spezifizéiert d'Zuel vun Zäit no wéi Cache Daten, déi net an der spezifizéierter Zäit zougänglech sinn, aus dem Cache geläscht ginn onofhängeg vun hirer Frëschheet. E Wäert vu 60m an eiser Beispillkonfiguratioun bedeit datt Dateien, déi net no 60 zougänglech sinn, aus dem Cache geläscht ginn.
- max_size – spezifizéiert déi maximal Gréisst vum Cache. Et gi méi Parameteren déi Dir hei benotze kënnt (liest d'NGINX Dokumentatioun fir méi Informatioun).
D'Variabelen an der Direktiv fastcgi_cache_key ginn hei ënnen beschriwwen.
NGINX benotzt se fir de Schlëssel (Identifier) vun enger Ufro ze berechnen. Wichteg ass, fir eng cachéiert Äntwert un de Client ze schécken, muss d'Ufro dee selwechte Schlëssel wéi eng cachéiert Äntwert hunn.
- $schema - Ufro Schema, HTTP oder HTTPS.
- $request_method - Ufromethod, normalerweis \GET\ oder \POST.
- $Host - dëst kann Hostnumm vun der Ufrolinn sinn, oder Hostnumm aus dem \Host Ufro Header Feld, oder de Servernumm deen eng Ufro entsprécht, an der Uerdnung vun der Virrang.
- $request_uri – heescht déi komplett ursprénglech URI URI (mat Argumenter).
Och d'$upstream_cache_status Variabel an der add_header X-Cache-Status Direktiv gëtt berechent fir all Ufro op déi NGINX reagéiert, egal ob et eng MISS ass (Äntwert net am Cache fonnt, krut vum Applikatiounsserver) oder en HIT (Äntwert aus Cache zerwéiert) oder eng vun den aneren ënnerstëtzte Wäerter.
Als nächst, an der Location Direktiv déi PHP-Ufroen un PHP-FPM passéiert, benotzt d'fastcgi_cache Direktiven fir de Cache ze aktivéieren deen Dir just uewen definéiert hutt.
Setzt och Cachingzäit fir verschidden Äntwerte mat der fastcgi_cache_valid Direktiv wéi gewisen.
fastcgi_cache CACHEZONE; fastcgi_cache_valid 60m;
Wann nëmmen d'Cachingzäit spezifizéiert ass wéi an eisem Fall, ginn nëmmen 200, 301 an 302 Äntwerte gespäichert. Awer Dir kënnt och d'Äntwerten explizit spezifizéieren oder all benotzen (fir all Äntwertcode):
fastcgi_cache CACHEZONE; fastcgi_cache_valid 200 301 203 60m; fastcgi_cache_valid 404 10m; OR fastcgi_cache CACHEZONE; fastcgi_cache_valid any 10m;
Fine-Tuning FastCGI Caching Performance op Nginx
Fir d'Mindestzuel vun Mol festzeleeën, muss eng Ufro mam selwechte Schlëssel gemaach ginn ier d'Äntwert cache gëtt, enthält d'fastcgi_cache_min_uses Direktiv, entweder an der http{} oder >Server{} oder Location{} Kontext.
fastcgi_cache_min_uses 3
Fir d'Wiedervalidatioun vun ofgelaaften Cache-Elementer mat bedingte Ufroe mat den Headerfelder \If-Modified-Since an \If-None-Match z'erméiglechen, füügt d'fastcgi_cache_revalidate Direktiv an der >http{} oder Server{} oder Location{} Kontext.
fastcgi_cache_revalidate on;
Dir kënnt och NGINX instruéieren cache Inhalt ze liwweren wann den Urspronk Server oder FCGI Server erof ass, mat der proxy_cache_use_stale Direktiv, bannent der Standortdirektiv.
Dës Probekonfiguratioun bedeit datt wann NGINX e Feeler, Timeout an irgendeng vun de spezifizéierte Feeler vum Upstream-Server kritt an eng al Versioun vun der ugefrote Datei am cachéierten Inhalt huet, liwwert et déi stale Datei.
proxy_cache_use_stale error timeout http_500;
Eng aner nëtzlech Direktiv fir d'Feintunioun vum FCGI Caching Leeschtung ass fastcgi_cache_background_update déi a Verbindung mat der proxy_cache_use_stale Direktiv funktionnéiert. Wann op gesat ass, instruéiert et NGINX fir alen Inhalter ze déngen wann Cliente fir eng Datei ufroen déi ofgelaaf ass oder amgaang ass vum Upstream Server aktualiséiert ze ginn.
fastcgi_cache_background_update on;
De fastcgi_cache_lock ass och nëtzlech, fir d'Feintuning vun der Cache-Performance, datt wa verschidde Cliente fir deeselwechten Inhalt ufroen deen net am Cache ass, NGINX nëmmen déi éischt Ufro un den Upstream Server weiderginn, Äntwert dann déngen déi aner Client Ufroe vum Cache.
fastcgi_cache_lock on;
Nodeems Dir all déi uewe genannten Ännerungen an der NGINX Konfiguratiounsdatei gemaach hutt, späichert a maach se zou. Da kontrolléiert d'Konfiguratiounsstruktur fir all Syntaxfehler ier Dir den NGINX Service nei starten.
# nginx -t # systemctl restart nginx
Als nächst, test ob de Cache richteg funktionnéiert, probéiert op Är Webapplikatioun oder Site ze kommen andeems Dir de folgende Curl Kommando benotzt (déi éischte Kéier soll e MISS uginn, awer spéider Ufroe sollten en HIT uginn wéi am Screenshot gewisen).
# curl -I http://testapp.linux-console.net
Hei ass en anere Screenshot deen NGINX zerstéiert Donnéeën weist.
Füügt Ausnahmen op Bypass Cache
Et ass méiglech Konditiounen ze setzen, ënner deenen NGINX keng cache Äntwerte fir Clienten schécken soll, andeems Dir d'fastcgi_cache_bypass Direktiv benotzt. A fir NGINX ze instruéieren, Äntwerte vum Upstream Server iwwerhaapt net ze cache, benotzt den fastcgi_no_cache.
Zum Beispill, wann Dir wëllt POST Ufroen an URLen mat enger Ufro String ëmmer op PHP goen. Als éischt, deklaréiert eng If Ausso fir d'Konditioun wéi follegt ze setzen.
set $skip_cache 0;
if ($request_method = POST) {
set $skip_cache 1;
}
Aktivéiert dann déi uewe genannte Ausnam an der Location Direktiv déi PHP-Ufroen un PHP-FPM passéiert, andeems Dir fastcgi_cache_bypass an fastcgi_no_cache Direktiven benotzt.
fastcgi_cache_bypass $skip_cache; fastcgi_no_cache $skip_cache;
Et gi vill aner Deeler vun Ärer Säit fir déi Dir vläicht net wëllt Inhalt Caching aktivéieren. Déi folgend ass e Beispill NGINX Konfiguratioun fir d'Performance vun engem WordPress Site ze verbesseren, geliwwert um nginx.com Blog.
Fir et ze benotzen, maacht Ännerungen (wéi den Domain, Weeër, Dateinumm, etc.) fir ze reflektéieren wat an Ärem Ëmfeld existéiert.
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;
}
}
Aktivéiert Proxy Cache an NGINX
NGINX ënnerstëtzt och d'Caching vun Äntwerte vun anere Proxied Serveren (definéiert vun der proxy_pass Direktiv). Fir dësen Testfall benotze mir NGINX als Reverse Proxy fir eng Node.js Webapplikatioun, sou datt mir NGINX als Cache fir d'Node.js Applikatioun aktivéieren. All d'Konfiguratiounsdirektiven déi hei benotzt ginn hunn ähnlech Bedeitungen wéi d'FastCGI Direktiven an der viregter Sektioun, also wäerte mir se net erëm erklären.
Fir d'Caching vun Äntwerte vun engem Proxyserver z'erméiglechen, enthält d'proxy_cache_path Direktiv am Topniveau http{} Kontext. Fir ze spezifizéieren wéi Ufroe gespäichert ginn, kënnt Dir och d'proxy_cache_key Direktiv wéi follegt addéieren.
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;
Als nächst aktivéiert de Cache an der Location Direktiv.
location / {
proxy_pass http://127.0.0.1:3000;
proxy_cache PROXYCACHE;
proxy_cache_valid 200 302 10m;
proxy_cache_valid 404 1m;
}
Fir Konditiounen ze definéieren, ënner deenen NGINX keen cachéierten Inhalt schéckt a guer keng Äntwert vum Upstream-Server cache, enthält proxy_cache_bypass an proxy_no_cache.
proxy_cache_bypass $cookie_nocache $arg_nocache$arg_comment; proxy_no_cache $http_pragma $http_authorization;
Fine-Tuning Proxy Cache Leeschtung
Déi folgend Direktiven sinn nëtzlech fir d'Performance vum Proxy Cache ze feinjustéieren. Si hunn och déiselwecht Bedeitunge wéi d'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;
Fir méi Informatiounen a Caching Configuratioun Direktiven, kuckt d'Dokumentatioun fir déi zwee Haaptmoduler ngx_http_proxy_module.
Zousätzlech Ressourcen: Tipps fir WordPress Performance ze verbesseren.