HRdns.de

Cookie Datenschutzhinweis

Cookies helfen uns bei der Bereitstellung unserer Dienste. Um unsere Dienste im vollen Umfang verwenden zukönnen, bitten wir Sie um Erlaubnis Cookies verwenden zu dürfen.
Weitere Informationen zu diesem Thema finden Sie in unserer Datenschutzerklärung.

Varnish Test Konfiguration

Author:
Richard Hülsberg
E-Mail:
Veröffentlicht am:
Sprache:
bash

/**
 * @see https://www.varnish-cache.org/docs/3.0/tutorial/vcl.html
 * @see https://www.varnish-software.com/static/book/VCL_functions.html
 *
 * pass:         Varnish -> Webserver Vor Anfrage des Webserver festlegen, nicht cachen
 * hit_for_pass: Varnish -> Webserver Nach Antwort vom Webserver doch nicht cachen
 * lookup:       Varnish -> Webserver Anfrage senden (versuche zu cachen)
 * pipe:         Client -> Webserver Direkt durchreichen (bsp.: Video Streams)
 * deliver:      Varnish -> Client: Liefere vom Cache aus
 *
 * req:          Das Request Object welches vom Varnish an den Webserver gereicht wird.
 * beresp:       Der Response vom Webserver an den Varnish
 * resp:         Die Response die vom Varnish an den Client geht
 * obj:          Ein Cache Objekt, bsp eine Seite
 */

import std;

backend stage1 {
        .host = "81.88.37.59";
        .port = "80";
        .connect_timeout = 30s;
        .first_byte_timeout = 30s;
        .between_bytes_timeout = 30s;
        .probe = {
                .url = "/favicon.ico";
                .timeout = 3s;
                .interval = 10s;
                .window = 5;
                .threshold = 3;
        }
}

director stageservers round-robin {
        {
                .backend = stage1;
        }
}

/**
 * Client -> Varnish
 *
 * Verbindungs aufbau vom CLient zum Varnish
 *
 * @param req (rw)
 * @return (pass|lookup|pipe) | none
 */
sub vcl_recv {
        set req.backend = stageservers;

        std.collect(req.http.cookie);

        set req.http.Surrogate-Capability = "varnish=ESI/1.0";
        set req.http.host = "www.hrdns.de";
        set req.http.Varnish = "1";

        # Dont cache POST request
        if ( req.request == "POST" ) {
                return (pass);
        }

        if ( req.backend.healthy ) {
                # if backend is up, page will be reomve from cache after ttl+30s
                set req.grace = 30s;
        } else {
                # if backend is down, page will be reomve from cache after ttl+1h
                set req.grace = 1h;
        }

        return (lookup);
}

/**
 * Webserver -> Varnish
 *
 * Die Antwort vom Webserver zum Varnish
 *
 * @param req (rw)
 * @param bereq (rw)
 * @param beresp (rw)
 * @return (pass|hit_for_pass|pipe|deliver) | none
 */
sub vcl_fetch {
        if (beresp.http.Surrogate-Control ~ "ESI") {
                set beresp.do_esi = true;
        }

        if ( beresp.http.Pragma ~ "no-cache" ) {
                return (hit_for_pass);
        }

        # Overwrite Server Cache TTL to 1 hour
        set beresp.ttl = 30m;

        # maximum grace value from vcl_recv
        set beresp.grace = 1h;
}

/**
 * Varnish -> Server (immer, kein Cache)
 *
 * Eine Anfrage die nicht gecached werden soll.
 *
 * @param req (rw)
 * @param bereq (rw)
 * @return pass | ???
 */
sub vcl_pass {
        return (pass);
}

/**
 * Varnish -> Client
 *
 * Ein Aufruf der nicht gecached wurde.
 *
 * @param req (rw)
 * @param bereq (rw)
 * @return ???
 */
sub vcl_miss {
        return (fetch);
}

/**
 * Varnish -> Client
 *
 * Eine Seite die aus dem Cache kommt
 *
 * @param req (rw)
 * @param obj (r)
 * @param obj.ttl (rw)
 * @param obj.grace (rw)
 * @return ???
 */
sub vcl_hit {
        return (deliver);
}

/**
 * Varnish -> Client
 *
 * Eine Error Seite die ausgeliefert wird vom Varnish
 *
 * @param req (rw)
 * @param obj (rw)
 * @param resp (rw)
 * @eturn ???
 */
sub vcl_error {
        set obj.ttl = 0s;
        synthetic {"status: "} + obj.status + {"<br> response: "} + obj.response + {"<br> xid: "} + req.xid;
        return (deliver);
}

/**
 * Varnish -> Client
 *
 * Die Antwort die vom Varnish an den Client geht
 *
 * @param req (rw)
 * @param obj.hits (r)
 * @param resp (rw)
 * @return deliver | ???
 */
sub vcl_deliver {
        unset resp.http.Server;
        unset resp.http.X-Powered-By;
        unset resp.http.Vary;

        set resp.http.Cache-Control = "no-cache, no-store, must-revalidate, proxy-revalidate";
        set resp.http.Pragma = "no-cache";
        set resp.http.Expires = "Tue, 01 Jan 1985 00:00:00 GMT";

        if (obj.hits > 0) {
                set resp.http.X-Cache = {"HIT: "} + obj.hits;
        } else {
                set resp.http.X-Cache = "MISS";
        }
        unset resp.http.Surrogate-Control;
        return (deliver);
}

/**
 * Client -> Varnish -> Webserver
 *
 * Eine Anfrage vom Client die Byte getreu hin und her gereicht wird
 *
 * @param req (rw)
 * @param bereq (rw)
 * @return ???
 */
sub vcl_pipe {
        set bereq.http.connection = "close";
}

/**
 * Varnish itern???
 *
 * Erstellen der Hash ID fuer den Varnish???
 *
 * @param req (rw)
 * @return hash|???
 */
sub vcl_hash  {
        hash_data(req.url);
        if (req.http.host) {
                hash_data(req.http.host);
        } else {
                hash_data(server.ip);
        }

        # Hash Cookie Accept
        #if (req.http.cookie ~ "cookie_accept=") {
        #       set req.http.X-COOKIE-ACCEPT = regsub(req.http.cookie, ".*cookie_accept=([^;]+);.*","\1");
        #       hash_data(req.http.X-COOKIE-ACCEPT);
        #       remove req.http.X-TMP;
        #}

        return (hash);
}