CentOS 7.5 stellt Varnish-Cache-Serverfunktion bereit

[root@varnish ~]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo 
: : : : : : : : : : : : : : :
#
# Dies ist eine Beispiel-VCL-Datei für Varnish.
#
# Es tut standardmäßig nichts und delegiert die Kontrolle an den
# eingebaute VCL. Die eingebaute VCL wird aufgerufen, wenn kein expliziter
# return-Anweisung.
#
# Siehe die VCL-Kapitel im Benutzerhandbuch unter https://www.varnish-cache.org/docs/
# und http://varnish-cache.org/trac/wiki/VCLExamples für weitere Beispiele.

# Markierung, die dem VCL-Compiler mitteilt, dass diese VCL angepasst wurde an die
# neues 4.0-Format.
vcl 4.0;
Importdirektoren;
std importieren;
# Standard-Backend-Definition. Legen Sie diese so fest, dass sie auf Ihren Inhaltsserver verweist.
Probe backend_healthcheck {
.url="/"; #Greifen Sie auf den Stammpfad des Backend-Servers zu.Intervall = 5s; #Anforderungszeitintervall.Timeout = 1s; #Anforderungs-Timeout.Fenster = 5; #Geben Sie die Anzahl der Abfragen 5-mal an.Schwellenwert = 3; #Wenn es 3 Fehler gibt, bedeutet dies, dass der Backend-Server ausgefallen ist}
backend web1 { #definieren Sie den Backend-Server.host = "192.168.20.4"; #IP oder Domänenname des Hosts (also des Backend-Hosts), der umgeleitet werden soll.port = "80"; #geben Sie die Portnummer des Backend-Servers an.probe = backend_healthcheck; #Healthcheck ruft den durch backend_healthcheck definierten Inhalt auf}
Backend Web2 {
.host = "192.168.20.3";   
.port = "80";
.probe = backend_healthcheck;
}
acl purgers { #Zugriffskontrollliste "127.0.0.1" definieren;
    "lokaler Host";
    "192.168.20.0/24";
    !"192.168.20.4";
}
sub vcl_init { #Rufen Sie vcl_init auf, um die Subroutine zu initialisieren und die Backend-Hostgruppe, d. h. die Direktoren, zu erstellen.
    new web_cluster = directors.round_robin(); #Verwenden Sie das neue Schlüsselwort, um ein Director-Objekt zu erstellen und verwenden Sie den Round_Robin-Algorithmus web_cluster.add_backend(web1); #Fügen Sie einen Back-End-Serverknoten hinzu web_cluster.add_backend(web2);
}
unter vcl_recv {
    set req.backend_hint = web_cluster.backend(); #Geben Sie den Backend-Knoten der Anforderung an web_cluster definierter Backend-Knoten if (req.method == "PURGE") { #Beurteilen Sie, ob der Anforderungsheader des Clients PURGE ist
        if (!client.ip ~ purgers) { #Wenn ja, prüfen Sie, ob die IP-Adresse des Clients in der ACL-Zugriffskontrollliste steht.
            return (synth(405, "Nicht zulässig.")); #Wenn nicht, gib einen 405-Statuscode an den Client zurück und gib die definierte Seite zurück.
    }
    return (purge); #Wenn es durch ACL definiert ist, wird es durch Purge behandelt.
}
wenn (req.method != "GET" &&
    req.method != "HEAD" &&
    Anforderungsmethode != "PUT" &&
    Anforderungsmethode != "POST" &&
    Anforderungsmethode != "TRACE" &&
    req.method != "OPTIONEN" &&
    req.method != "PATCH" &&
    req.method != "DELETE") { #Beurteilen Sie den Anforderungstyp des Clients return (Pipe);
    }
wenn (req.method != "GET" und req.method != "HEAD") {
    return (pass); #Wenn es nicht GET oder HEAD ist, übergeben Sie es.
}
wenn (req.url ~ "\.(php|asp|aspx|jsp|do|ashx|shtml)($|\?)") {
    return (pass); #Wenn der Client auf eine Datei mit der Endung .php zugreift, übergeben Sie sie zur Verarbeitung an „pass“.
}
wenn (req.http.Authorization) {
    return (pass); #Wenn der vom Client angeforderte Seitentyp eine Authentifizierung erfordert, übergeben Sie ihn an den Prozess}
wenn (req.http.Accept-Encoding) {
    if (req.url ~ "\.(bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)$") {
    unset req.http.Accept-Encoding; #Stornieren Sie den vom Client empfangenen Komprimierungstyp} elseif (req.http.Accept-Encoding ~ "gzip") {
        set req.http.Accept-Encoding = "gzip"; #Wenn ein Gzip-Typ vorhanden ist, markieren Sie den Gzip-Typ.
    } elseif (req.http.Accept-Encoding ~ "deflate") {
        setze req.http.Accept-Encoding = "deflate";
    } anders {
    unset req.http.Accept-Encoding; #Andere undefinierte Seiten heben auch den vom Client empfangenen Komprimierungstyp auf.
    }
   }
if (req.url ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
    unset req.http.cookie; #Den Cookie-Wert des Clients abbrechen.
    return (Hash); #Leitet die Anforderung an die Hash-Subroutine weiter, d. h. überprüft den lokalen Cache.
}
if (req.restarts == 0) { #Beurteilen Sie, ob es sich um die erste Anfrage vom Client handelt. if (req.http.X-Forwarded-For) { #Wenn es die erste Anfrage ist, legen Sie die IP-Adresse des Clients fest.
        setze req.http.X-Forwarded-For = req.http.X-Forwarded-For + ", " + client.ip;
    } anders {
    setze req.http.X-Forwarded-For = client.ip;
    }
}
Rückgabe (Hash);
}
sub vcl_hash {
    hash_data(req.url); #Zeigen Sie die vom Client angeforderte Seite an und führen Sie ein Hashing durch
    wenn (req.http.host) {
        hash_data(req.http.host); #Host des Clients festlegen} else {
        hash_data(server.ip); #Server-IP festlegen
    }
    zurückgeben (nachschlagen);
}
unter vcl_hit {
    if (req.method == "PURGE") { #Wenn es HIT ist und der Client-Anforderungstyp PURGE ist, geben Sie den Statuscode 200 zurück und geben Sie die entsprechende Seite zurück.
        return (synth(200, "Gelöscht."));
    }
    zurückgeben (liefern);
}

unter vcl_miss {
  wenn (req.method == "PURGE") {
        return (synth(404, "Gelöscht.")); #Wenn es ein Fehler ist, gib 404 zurück
    }
    zurückgeben (holen);
}
unter vcl_deliver {
    if (Objekttreffer > 0) {
        set resp.http.CXK = "HIT-from-varnish"; #HTTP-Header festlegen X-Cache = Hit
        set resp.http.X-Cache-Hits = obj.hits; #Gibt die Anzahl der Befehle zurück} else {
    setze resp.http.X-Cache = "MISS";
    }
    unset resp.http.X-Powered-By; #Anzeige der Webversion abbrechenunset resp.http.Server; #Anzeige des Varnish-Dienstes abbrechenunset resp.http.X-Drupal-Cache; #Anzeige des zwischengespeicherten Frameworks abbrechenunset resp.http.Via; #Anzeige der Dateiinhaltsquelle abbrechenunset resp.http.Link; #Anzeige der HTML-Hyperlinkadresse abbrechenunset resp.http.X-Varnish; #Anzeige der Varnish-ID abbrechen
    set resp.http.xx_restarts_count = req.restarts; #Anzahl der Client-Anfragen festlegen set resp.http.xx_Age = resp.http.Age; #Länge der zwischengespeicherten Dateien anzeigen #set resp.http.hit_count = obj.hits; #Anzahl der Cache-Treffer anzeigen #unset resp.http.Age;
    zurückgeben (liefern);
}
unter vcl_pass {
    return (fetch); #Die vom Backend-Server zurückgegebenen Daten lokal zwischenspeichern}
unter vcl_backend_response {
    setze beresp.grace = 5m; #zusätzliche Nachfrist zwischenspeichernwenn (beresp.status == 499 || beresp.status == 404 || beresp.status == 502) {
        setze beresp.uncacheable = true; #Wenn der Backend-Server mit einem Statuscode von 449 usw. antwortet, nicht zwischenspeichern}
    wenn (bereq.url ~ "\.(php|jsp)(\?|$)") {
        setze beresp.uncacheable = true; #Wenn es eine PHP-Seite ist, wird sie nicht zwischengespeichert} else {
        wenn (bereq.url ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico)($|\?)") {
        setze beresp.ttl = 15m; #Wenn es mit dem oben genannten endet, zwischenspeichere es für 15 Minuten unset beresp.http.Set-Cookie;
        } elseif (bereq.url ~ "\.(gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
            setze beresp.ttl = 30m; #Cache für 30 Minuten, setze beresp.http.Set-Cookie zurück;
        } anders {
            setze beresp.ttl = 10m; #Lebensdauer 10 Minuten, nicht gesetzt beresp.http.Set-Cookie;
        }
    }
    zurückgeben (liefern);
}
sub vcl_purge {
    return (Synth (200, "Erfolg"));
}
sub vcl_backend_error {
    wenn (beresp.status == 500 ||
        beresp.status == 501 ||
        beresp.status == 502 ||
        beresp.status == 503 ||
        beresp.status == 504) {
        return (Wiederholen); #Wenn der Statuscode einer der oben genannten ist, erneut anfordern}
}
sub vcl_fini {
    zurück (ok);
}
#Nach der Bearbeitung speichern und beenden.
[root@varnish-Lack]# varnishd -f /usr/local/var/varnish/example.vcl -s malloc,200M -a 0.0.0.0:80
#Starten Sie den Varnish-Dienst und lauschen Sie auf Port 80 aller lokalen IP-Adressen. -f gibt die VCL-Datei an und -s gibt die Kapazität für die Speicherung des Caches an. [root@varnish ~]# varnishlog #Nachdem Varnish gestartet wurde, können Sie diesen Befehl ausführen, um das Protokoll anzuzeigen.

[root@localhost ~]# curl -X "PURGE" 192.168.20.5 #Varnish-Cache löschen

vcl 4.0;
Importdirektoren;
std importieren;
Probe backend_healthcheck {
.url="/"; 
.Intervall = 5s;
.Zeitüberschreitung = 1s;
.Fenster = 5; 
.Schwellenwert = 3; 
}
Backend web1 { 
.host = "192.168.20.4"; 
.port = "80"; 
.probe = backend_healthcheck; 
}
Backend Web2 {
.host = "192.168.20.3";   
.port = "80";
.probe = backend_healthcheck;
}
ACL-Plünderer { 
    "127.0.0.1";
    "lokaler Host";
    "192.168.20.0/24";
    !"192.168.20.4";
}
unter vcl_init { 
    neuer Webcluster = Direktoren.round_robin();
    web_cluster.add_backend(web1); 
    web_cluster.add_backend(web2);
}
unter vcl_recv {
    setze req.backend_hint = web_cluster.backend(); 
    wenn (req.method == "PURGE") { 
        wenn (!client.ip ~ purgers) {  
            return (synth(405, "Nicht zulässig.")); 
    }
    zurückgeben (bereinigen); 
}
wenn (req.method != "GET" &&
    req.method != "HEAD" &&
    Anforderungsmethode != "PUT" &&
    Anforderungsmethode != "POST" &&
    Anforderungsmethode != "TRACE" &&
    req.method != "OPTIONEN" &&
    req.method != "PATCH" &&
    req.method != "LÖSCHEN") {  
        Rücklauf (Rohr);
    }
wenn (req.method != "GET" und req.method != "HEAD") {
    Rückpass);
}
wenn (req.url ~ "\.(php|asp|aspx|jsp|do|ashx|shtml)($|\?)") {
    Rückpass); 
}
wenn (req.http.Authorization) {
    Rückpass); 
}
wenn (req.http.Accept-Encoding) {
    if (req.url ~ "\.(bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)$") {
    req.http.Accept-Encoding aufheben; 
    } elseif (req.http.Accept-Encoding ~ "gzip") {
        setze req.http.Accept-Encoding = "gzip"; 
    } elseif (req.http.Accept-Encoding ~ "deflate") {
        setze req.http.Accept-Encoding = "deflate";
    } anders {
    req.http.Accept-Encoding aufheben;
    }
   }
if (req.url ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
    req.http.cookie nicht gesetzt; 
    Rückgabe (Hash);  
}
wenn (req.restarts == 0) { 
    wenn (req.http.X-Forwarded-For) {  
        setze req.http.X-Forwarded-For = req.http.X-Forwarded-For + ", " + client.ip;
    } anders {
    setze req.http.X-Forwarded-For = client.ip;
    }
}
Rückgabe (Hash);
}
sub vcl_hash {
    hash_data(erforderliche URL); 
    wenn (req.http.host) {
        hash_data(req.http.host); 
    } anders {
        hash_data(server.ip); 
    }
    zurückgeben (nachschlagen);
}
unter vcl_hit {
    wenn (req.method == "PURGE") { 
        return (synth(200, "Gelöscht."));
    }
    zurückgeben (liefern);
}

unter vcl_miss {
  wenn (req.method == "PURGE") {
        return (synth(404, "Gelöscht."));
    }
    zurückgeben (holen);
}
unter vcl_deliver {
    if (Objekttreffer > 0) {
        setze resp.http.CXK = "HIT-aus-Lack";
        setze resp.http.X-Cache-Hits = obj.hits; 
    } anders {
    setze resp.http.X-Cache = "MISS";
    }
    nicht gesetzt bzw. http.X-Powered-By; 
    nicht gesetzt bzw. http.Server;  
    nicht gesetzt bzw. http.X-Drupal-Cache; 
    nicht gesetzt bzw. http.Via; 
    nicht gesetzt bzw. http.Link; 
    nicht gesetzt bzw. http.X-Varnish; 
    setze resp.http.xx_restarts_count = req.restarts; 
    setze resp.http.xx_Age = resp.http.Age; 
    #set resp.http.hit_count = obj.hits; 
    #unset bzw.http.Alter;
    zurückgeben (liefern);
}
unter vcl_pass {
    zurückgeben (holen); 
}
unter vcl_backend_response {
    setze beresp.grace = 5m; 
    wenn (beresp.status == 499 || beresp.status == 404 || beresp.status == 502) {
        setze beresp.uncacheable = true;
    }
    wenn (bereq.url ~ "\.(php|jsp)(\?|$)") {
        setze beresp.uncacheable = true; 
    } anders {
        wenn (bereq.url ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico)($|\?)") {
        setze beresp.ttl = 15m; 
        nicht gesetzt, beresp.http.Set-Cookie;
        } elseif (bereq.url ~ "\.(gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
            setze beresp.ttl = 30m;
            nicht gesetzt, beresp.http.Set-Cookie;
        } anders {
            setze beresp.ttl = 10m;
            nicht gesetzt, beresp.http.Set-Cookie;
        }
    }
    zurückgeben (liefern);
}
sub vcl_purge {
    return (Synth (200, "Erfolg"));
}
sub vcl_backend_error {
    wenn (beresp.status == 500 ||
        beresp.status == 501 ||
        beresp.status == 502 ||
        beresp.status == 503 ||
        beresp.status == 504) {
        Rückkehr (Wiederholen); 
    }
}
sub vcl_fini {
    zurück (ok);
}

Importdirektoren;
Probe backend_healthcheck {
    .url = "/";
    .Zeitüberschreitung = 1s;
    .Intervall = 5s;
    .Fenster = 5;
    .Schwellenwert = 3;
}
Backend web1 {
    .host = "192.168.20.3";
    .port = "80";
    .probe = backend_healthcheck;
}
Backend Web2 {
    .host = "192.168.20.4";
    .port = "80";
    .probe = backend_healthcheck;
}
unter vcl_init {
    neuer Webcluster = Direktoren.round_robin();
    web_cluster.add_backend(web1);
    web_cluster.add_backend(web2);
}
unter vcl_recv {
    setze req.backend_hint = web_cluster.backend();
}