当前位置: 首页 > 工具软件 > Varnish Agent > 使用案例 >

varnish详解

贲骏喆
2023-12-01

开源解决方案:
squid:
varnish:默认端口:6081、127.20.0.1:6082

    varnish官方站点: http://www.varnish-cache.org/
        Community
        Enterprise

         This is Varnish Cache, a high-performance HTTP accelerator. 

    程序架构:
        Manager进程
        Cacher进程,包含多种类型的线程:
            accept, worker, expiry, ... 
        shared memory log:
            统计数据:计数器;
            日志区域:日志记录;
                varnishlog, varnishncsa, varnishstat... 

        配置接口:VCL
            Varnish Configuration Language, 
                vcl complier --> c complier --> shared object 

    varnish的程序环境:
        /etc/varnish/varnish.params: 配置varnish服务进程的工作特性,例如监听的地址和端口,缓存机制;
            Unit File: EnvironmentFile=""
        /etc/varnish/default.vcl:配置各Child/Cache线程的缓存策略;
            VCL: dsl, subroutines, 子例程
        主程序:
            /usr/sbin/varnishd
        CLI interface:
            /usr/bin/varnishadm
        Shared Memory Log交互工具:
            /usr/bin/varnishhist
            /usr/bin/varnishlog
            /usr/bin/varnishncsa
            /usr/bin/varnishstat
            /usr/bin/varnishtop     
        测试工具程序:
            /usr/bin/varnishtest
        VCL配置文件重载程序:
            /usr/sbin/varnish_reload_vcl
        Systemd Unit File:
            /usr/lib/systemd/system/varnish.service
                varnish服务
            /usr/lib/systemd/system/varnishlog.service
            /usr/lib/systemd/system/varnishncsa.service 
                日志持久的服务;

实例:将varnish服务设置内容http服务
126.180:httpd服务
yum -y install httpd

    vim /var/www/html/index.html
    not 1

systemctl start httpd.service

102.70:varnish服务器
    yum -y install varnish

    vim /etc/varnish/default.vcl 
    # Default backend definition. Set this to point to your content server.
    //默认端定义。将其设置为指向内容服务器
    backend default {
        .host = "172.20.126.180";
        //内容服务器的ip
        .port = "80";
        //定义的端口

    启用:
        systemctl start varnish 

    重新加载服务直接运行即可:
        varnish_reload_vcl 

测试:172.20.102.70:6081将显示内容跳转到126.180的httpd服务上;

    varnish的缓存存储机制( Storage Types):
        -s [name=]type[,options]

        · malloc[,size]
            内存存储,[,size]用于定义空间大小;重启后所有缓存项失效;
        · file[,path[,size[,granularity]]]
            磁盘文件存储,黑盒;重启后所有缓存项失效;
        · persistent,path,size
            文件存储,黑盒;重启后所有缓存项有效;实验;

    varnish程序的选项:
        程序选项:/etc/varnish/varnish.params文件
            -a address[:port][,address[:port][...],默认为6081端口; 
            -T address[:port],默认为6082端口;
            -s [name=]type[,options],定义缓存存储机制;
            -u user
            -g group
            -f config:VCL配置文件;
            -F:运行于前台;
            ...
        运行时参数:/etc/varnish/varnish.params文件, DEAMON_OPTS
            DAEMON_OPTS="-p thread_pool_min=5 -p thread_pool_max=500 -p thread_pool_timeout=300"

            -p param=value:设定运行参数及其值; 可重复使用多次;
            -r param[,param...]: 设定指定的参数为只读状态; 

    重载vcl配置文件:
        ~ ]# varnish_reload_vcl

    varnishadm
        -S /etc/varnish/secret -T [ADDRESS:]PORT 

        help [<command>]
        ping [<timestamp>]
        auth <response>
        quit
        banner
        status
        start
        stop
        vcl.load <configname> <filename>
        vcl.inline <configname> <quoted_VCLstring>
        vcl.use <configname>
        vcl.discard <configname>
        vcl.list
        param.show [-l] [<param>]
        param.set <param> <value>
        panic.show
        panic.clear
        storage.list
        vcl.show [-v] <configname>
        backend.list [<backend_expression>]
        backend.set_health <backend_expression> <state>
        ban <field> <operator> <arg> [&& <field> <oper> <arg>]...
        ban.list    

        配置文件相关:
            vcl.list:显示类似于ls命令
            vcl.load:装载,加载并编译;
            vcl.use:激活;
            vcl.discard:删除;
            vcl.show [-v] <configname>:查看指定的配置文件的详细信息;

        运行时参数:
            param.show -l:显示列表;
            param.show <PARAM>
            param.set <PARAM> <VALUE>

        缓存存储:
            storage.list

        后端服务器:
            backend.list 

    VCL:
        ”域“专有类型的配置语言;

        state engine:状态引擎;

        VCL有多个状态引擎,状态之间存在相关性,但状态引擎彼此间互相隔离;每个状态引擎可使用return(x)指明关联至哪个下一级引擎;每个状态引擎对应于vcl文件中的一个配置段,即为subroutine

            vcl_hash --> return(hit) --> vcl_hit

        vcl_recv的默认配置:

            sub vcl_recv {
                if (req.method == "PRI") {
                    /* We do not support SPDY or HTTP/2.0 */
                    return (synth(405));
                }
                if (req.method != "GET" &&
                req.method != "HEAD" &&
                req.method != "PUT" &&
                req.method != "POST" &&
                req.method != "TRACE" &&
                req.method != "OPTIONS" &&
                req.method != "DELETE") {
                    /* Non-RFC2616 or CONNECT which is weird. */
                    return (pipe);
                }

                if (req.method != "GET" && req.method != "HEAD") {
                    /* We only deal with GET and HEAD by default */
                    return (pass);
                }
                if (req.http.Authorization || req.http.Cookie) {
                    /* Not cacheable by default */
                    return (pass);
                }
                    return (hash);
                }
            }

        Client Side:
            vcl_recv, vcl_pass, vcl_hit, vcl_miss, vcl_pipe, vcl_purge, vcl_synth, vcl_deliver

            vcl_recv:
                hash:vcl_hash
                pass: vcl_pass 
                pipe: vcl_pipe
                synth: vcl_synth
                purge: vcl_hash --> vcl_purge

            vcl_hash:
                lookup:
                    hit: vcl_hit
                    miss: vcl_miss
                    pass, hit_for_pass: vcl_pass
                    purge: vcl_purge

        Backend Side:
            vcl_backend_fetch, vcl_backend_response, vcl_backend_error

        两个特殊的引擎:
            vcl_init:在处理任何请求之前要执行的vcl代码:主要用于初始化VMODs;
            vcl_fini:所有的请求都已经结束,在vcl配置被丢弃时调用;主要用于清理VMODs;

    vcl的语法格式:
        (1) VCL files start with vcl 4.0;
        (2) //, # and /* foo */ for comments;
        (3) Subroutines are declared with the sub keyword; 例如sub vcl_recv { ...};
            //用sub关键词定义子例程
        (4) No loops, state-limited variables(受限于引擎的内建变量);
            //不支持循环,
        (5) Terminating statements with a keyword for next action as argument of the return() function, i.e.: return(action);用于实现状态引擎转换;
        (6) Domain-specific;
            //特定的领域
    The VCL Finite State Machine
        //VCL有限状态机
        (1) Each request is processed separately;
            //每个请求是分开处理的
        (2) Each request is independent from others at any given time;
            //每个请求在任何给定的时间都是独立于其他请求的
        (3) States are related, but isolated;
            //即便是有状态、有关联性,但彼此否是隔离的
        (4) return(action); exits one state and instructs Varnish to proceed to the next state;
            //决定下一跳是哪里
        (5) Built-in VCL code is always present and appended below your own VCL;

    三类主要语法:
        sub subroutine {
            ...
        }

        if CONDITION {
            ...
        } else {    
            ...
        }

        return(), hash_data()

    VCL Built-in Functions and Keywords
        函数:
            regsub(str, regex, sub)
            regsuball(str, regex, sub)
            ban(boolean expression)
            hash_data(input)
            synthetic(str)

        Keywords:
            call subroutine, return(action),new,set,unset 

        操作符:
            ==, !=, ~, >, >=, <, <=
            逻辑操作符:&&, ||, !
            变量赋值:=

实例:obj.hits是内建变量,用于保存某缓存项的从缓存中命中的次
102.70:varnish
vim /etc/varnish/default.vcl /在最后结尾处定义
if (obj.hits > 0) {
set resp.http.X-Varnish = "Hit via " + server.ip;
} else {
set resp.http.X-Varnish = "Miss from " + server.ip;
}
用于加载default.val文件中添加的内容:
varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
//可获取帮助:help
vcl.load conf1 default.vcl //编译成功了 conf1:名字随意 default.vcl:文件
200
VCL compiled.

        vcl.use conf1                   //使用加载conf1
        200        
        VCL 'conf1' now active

        vcl.discard                     //用于删除 后面跟上要删除的内容即可;

测试:google:172.20.102.70:6081
        打开开发工具:显示刚才定义的内容
            Via:1.1 varnish-v4
            X-Varnish:Hit via 172.20.102.70         

测试级:102.71
    wget  http://172.20.102.70:6081         //可将102.70的网站页面能下载下来 
    wget -O - -q http://172.20.102.70:6081  //查看此网站的内容

问题:拒绝它访问:
102.70:varnish
vim /etc/varnish/default.vcl //在 sub vcl_recv 处定义将它拒绝访问
sub vcl_recv {
if(req.http.User-Agent ~ "curl") {
return(synth(403));
}

varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
    varnish> vcl.load conf2 default.vcl
    200        
    VCL compiled.
    vcl.list
    200        
    available       0 boot
    active          0 conf1
    available       0 conf2

    vcl.use conf2
    200        
    VCL 'conf2' now

测试机:102.71:
    curl http://172.20.102.70:6081      //将会显示拒绝访问

问题:如有人访问admin的URL时直接拒绝访问:
126.180:http服务:
mkdir -pv /var/www/html/admin
vim /var/www/html/admin/index.html
admin

102.70:varnish
    vim /etc/varnish/default.vcl        //跟在刚才定义的curl内容后面即可
        if(req.url ~ "^/admin") {
            return(synth(403));
        }

    varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
        vcl.load conf2 default.vcl
        200        
        VCL compiled.
        vcl.use conf2
        200        
        VCL 'conf2' now active

测试机:
    wget -O - -q http://172.20.102.70:6081/admin    //将无法使用admin的url的路径 

变量类型:
    内建变量:
        req.*:request,表示由客户端发来的请求报文相关;
            req.http.*
                req.http.User-Agent, req.http.Referer, ...
        bereq.*:由varnish发往BE主机的httpd请求相关;
            bereq.http.*
        beresp.*:由BE主机响应给varnish的响应报文相关;
            beresp.http.*
        resp.*:由varnish响应给client相关;
        obj.*:存储在缓存空间中的缓存对象的属性;只读;

常用变量:
    bereq.*, req.*:
    bereq.http.HEADERS
    bereq.request, req.request:请求方法;
        bereq.url, req.url:请求的url;
        bereq.proto:请求的协议版本;
        bereq.backend:指明要调用的后端主机;

        req.http.Cookie:客户端的请求报文中Cookie首部的值; 
        req.http.User-Agent ~ "chrome"

    beresp.*, resp.*:
        beresp.http.HEADERS
        beresp.status, resp.status:响应的状态码;
        reresp.proto, resp.proto:协议版本;
        beresp.backend.name:BE主机的主机名;
        beresp.ttl:BE主机响应的内容的余下的可缓存时长;

    obj.*
        obj.hits:此对象从缓存中命中的次数;
        obj.ttl:对象的ttl值

    server.*
        server.ip:varnish主机的IP;
        server.hostname:varnish主机的Hostname;
    client.*
        client.ip:发请求至varnish主机的客户端IP;

    用户自定义:
        set 
        unset 

示例1:强制对某类资源的请求不检查缓存:
vcl_recv {
if (req.url ~ "(?i)^/(login|admin)") { //请求的url如果是login或者是admin
return(pass); //不检查缓存
}
}

102.70:
vim /etc/varnish/default.vcl //修改内容
if(req.url ~ "^/admin") {
return(pass); //不缓存
}

varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
    vcl.load conf6 default.vcl

    vcl.use conf6

测试:Google:172.20.102.70:6081/admin 启用开发工具
Via:1.1 varnish-v4
X-Varnish:Miss from 172.20.102.70 //没有缓存

示例2:对于特定类型的资源,例如公开的图片等,取消其私有标识,并强行设定其可以由varnish缓存的时长; 定义在vcl_backend_response中;

if (beresp.http.cache-control !~ "s-maxage") {   //后端服务发的的响应报文 首部名称:cache-control !~:不匹配不到 s-maxage
    if (bereq.url ~ "(?i)\.(jpg|jpeg|png|gif|css|js)$") {  //静态内容
        unset beresp.http.Set-Cookie;   //取消后端服务器发来的Set-Cookie
        set beresp.ttl = 3600s;     //强行将静态内容过期时间 为1小时
    }
}
注意:出现这样情况需手动清理缓存

示例3:定义在vcl_recv中;
vim /etc/varnish/default.vcl
if (req.restarts == 0) { //请求被重启的
if (req.http.X-Fowarded-For) { //请求报文中
set req.http.X-Forwarded-For = req.http.X-Forwarded-For + "," + client.ip;
} else {
set req.http.X-Forwarded-For = client.ip;
}
}

varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
vcl.load conf5 default.vcl
200
VCL compiled.
vcl.use conf5
200
VCL 'conf5' now active

126.180:http服务
vim /etc/httpd/conf/httpd.conf
<IfModule log_config_module>
LogFormat "%{X-Forwarded-For}i %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined

systemctl restart httpd.service

    缓存对象的修剪:purge, ban 

        配置purge操作:
            (1) 能执行purge操作
                sub vcl_purge {
                    return (synth(200,"Purged"));
                }

            (2) 何时执行purge操作
                sub vcl_recv {
                    if (req.method == "PURGE") {
                        return(purge);
                    }
                    ...
                }

实例:配置purge:
102.70:
vim /etc/varnish/default.vcl //sub vcl_recv中配置
if (req.method == "PURGE") {
return(purge);
}

        sub vcl_purge {
            return(synth(200,"Ok."));
        }

    varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
        vcl.load conf6 default.vcl
        200        
        VCL compiled.
        vcl.use conf6
        200        
        VCL 'conf6' now active
测试:curl -I http://172.20.102.70:6081

添加此类请求的访问控制法则:
    acl purgers {
        "127.0.0.0"/8;
        "10.1.0.0"/16;
    }

    sub vcl_recv {
        if (req.method == "PURGE") {
            if (!client.ip ~ purgers) {
                return(synth(405,"Purging not allowed for " + client.ip));
            }
            return(purge);
        }
        ...
    }

实例:基于acl请求访问控制:
acl不属于任何子进程

102.70:varnish
    vim /etc/varnish/default.vcl    //在backend default {  中定义

        acl purgers {
            "127.0.0.0"/8;
        }

        if (req.method == "PURGE") {
            if (client.ip ~ purgers) {
                    return(purge);
            } else {
                    return(synth(403,"not allowed for " + client.ip));
            }
        }

    varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
        vcl.load conf7 default.vcl
            200        
            VCL compiled.
            vcl.use conf7
            200        
            VCL 'conf7' now active

测试:客户端:
    curl -I http://172.20.102.70:6081

    curl -X PURGE http://172.20.102.70:6081
        <!DOCTYPE html>
        <html>
          <head>
            <title>403 not allowed for 172.20.102.71</title>
          </head>
          <body>
            <h1>Error 403 not allowed for 172.20.102.71</h1>
            <p>not allowed for 172.20.102.71</p>
            <h3>Guru Meditation:</h3>
            <p>XID: 131133</p>
            <hr>
            <p>Varnish cache server</p>
          </body>
        </html>

varnish服务:
    curl -X PURGE http://127.0.0.1:6081
        <!DOCTYPE html>
        <html>
          <head>
            <title>200 Ok.</title>
          </head>
          <body>
            <h1>Error 200 Ok.</h1>
            <p>Ok.</p>
            <h3>Guru Meditation:</h3>
            <p>XID: 131135</p>
            <hr>
            <p>Varnish cache server</p>
          </body>
        </html>

        Banning:
            (1) varnishadm:
                ban <field> <operator> <arg>

                示例:
                    ban req.url ~ (?i)^/javascripts

实例:不区分字符大小写:
126.180:http
mkdir -pv /var/www/html/ja
vim /var/www/html/ja/j.txt
j.txt

102.70:varnish
    varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
        ban req.url ~ (?i)^/ja
        200    

            (2) 在配置文件中定义,使用ban()函数;

            示例:
                if (req.method == "BAN") {
                    ban("req.http.host == " + req.http.host + " && req.url == " + req.url);
                    # Throw a synthetic page so the request won't go to the backend.
                    return(synth(200, "Ban added"));
                }   

                curl -X BAN http://www.ilinux.io/test1.html

                ban req.http.host==www.ilinux.io && req.url==/test1.html

    如何设定使用多个后端主机:
        backend default {
            .host = "172.16.100.6";
            .port = "80";
        }

        backend appsrv {
            .host = "172.16.100.7";
            .port = "80";
        }

        sub vcl_recv {              
            if (req.url ~ "(?i)\.php$") {
                set req.backend_hint = appsrv;
            } else {
                set req.backend_hint = default;
            }   

            ...
        }

        nginx: proxy_pass
        haproxy: use_backend

实例:使用负载均衡机制,实现多个后台主机:
172.20.126.180:http
cd /var/www/html/
for i in {1..10}; do echo "test $i" > test$i.txt; done
scp -rp * root@172.20.128.17:/var/www/html/

    systemctl restart httpd

172.20.128.17:http
    systemctl start httpd

172.20.102.70:varnish
    vim /etc/varnish/default.vcl
        import directors;

        # Default backend definition. Set this to point to your content server.
        backend default {
            .host = "172.20.126.180";
            .port = "80";
        }

        backend srv1 {
            .host = "172.20.126.180";
            .port = "80";
        }

        backend srv2 {
            .host = "172.20.128.17";
            .port = "80";
        }
        sub vcl_init {
            new websrvs = directors.round_robin();
            websrvs.add_backend(srv1);
            websrvs.add_backend(srv2);
        }

        acl purgers {
                "127.0.0.0"/8;
                "172.20.102.71"/32;
        }

        sub vcl_recv {
                set req.backend_hint = websrvs.backend();
        }

    varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
        vcl.load conf9 default.vcl
        200        
        VCL compiled.
        varnish> vcl.use conf9
        200        
        VCL 'conf9' now active

测试:客户端
    for i in {1..10}; do curl -I -s http://172.20.102.70:6081/test$i.txt ; done     //第一次无法生成缓存 第二次可以

    Director:
        varnish module; 
            使用前需要导入:
                import directors;

        示例:
            import directors;    # load the directors

            backend server1 {
                .host = 
                .port = 
            }
            backend server2 {
                .host = 
                .port = 
            }

            sub vcl_init {
                new GROUP_NAME = directors.round_robin();
                GROUP_NAME.add_backend(server1);
                GROUP_NAME.add_backend(server2);
            }

            sub vcl_recv {
                # send all traffic to the bar director:
                set req.backend_hint = GROUP_NAME.backend();
            }

        基于cookie的session sticky:
            sub vcl_init {
                new h = directors.hash();
                h.add_backend(one, 1);   // backend 'one' with weight '1'
                h.add_backend(two, 1);   // backend 'two' with weight '1'
            }

            sub vcl_recv {
                // pick a backend based on the cookie header of the client
                set req.backend_hint = h.backend(req.http.cookie);
            }

        基于随机的调度方式,支持服务器权重:
            sub vcl_init {
                new websrvs = directors.random();
                websrvs.add_backend(srv1,1);
                websrvs.add_backend(srv2,2);
            }           

    BE Health Check:
        backend BE_NAME {
            .host =
            .port = 
            .probe = {
                .url=
                .timeout=
                .interval= 
                .window=
                .threshold=
            }
        }

        10, 8

        .probe:定义健康状态检测方法;
            .request:发出的具体请求;
                .request = 
                    "GET /.healthtest.html HTTP/1.1"
                    "Host: www.magedu.com"
                    "Connection: close"
            .window:基于最近的多少次检查来判断其健康状态; 
            .threshold:最近.window中定义的这么次检查中至有.threshhold定义的次数是成功的;
            .interval:检测频度; 
            .timeout:超时时长;
            .expected_response:期望的响应码,默认为200;

        健康状态检测的配置方式:
            (1) probe PB_NAME  { }
                 backend NAME = {
                .probe = PB_NAME;
                ...
                 }

            (2) backend NAME  {
                .probe = {
                    ...
                }
            }

        示例:
            probe check {
                .url = "/.healthcheck.html";
                .window = 5;
                .threshold = 4;
                .interval = 2s;
                .timeout = 1s;
            }

            backend default {
                .host = "10.1.0.68";
                .port = "80";
                .probe = check;
            }

            backend appsrv {
                .host = "10.1.0.69";
                .port = "80";
                .probe = check;
            }

        手动设定BE主机的状态:
            sick:管理down; 
            healthy:管理up;
            auto:probe auto;

    设置后端的主机属性:
        backend BE_NAME {
            ...
            .connect_timeout = 0.5s;
            .first_byte_timeout = 20s;
            .between_bytes_timeout = 5s;
            .max_connections = 50;
        }

     varnish的运行时参数:
        线程模型:
            cache-worker
            cache-main
            ban lurker
            acceptor:
            epoll/kqueue:
            ...

        线程相关的参数:使用线程池机制管理线程;
            在线程池内部,其每一个请求由一个线程来处理; 其worker线程的最大数决定了varnish的并发响应能力;

            thread_pools:Number of worker thread pools. 最好小于或等于CPU核心数量; 
            thread_pool_max:The maximum number of worker threads in each pool. 每线程池的最大线程数;
            thread_pool_min:The minimum number of worker threads in each pool. 额外意义为“最大空闲线程数”;

                最大并发连接数 = thread_pools  * thread_pool_max

            thread_pool_timeout:Thread idle threshold.  Threads in excess of thread_pool_min, which have been idle for at least this long, will be destroyed.
            thread_pool_add_delay:Wait at least this long after creating a thread.
            thread_pool_destroy_delay:Wait this long after destroying a thread.

        Timer相关的参数:
            send_timeout:Send timeout for client connections. If the HTTP response hasn't been transmitted in this many seconds the session is closed.
            timeout_idle:Idle timeout for client connections. 
            timeout_req: Max time to receive clients request headers, measured from first non-white-space character to double CRNL.
            cli_timeout:Timeout for the childs replies to CLI requests from the mgt_param.

            设置方式:
                vcl.param 
                param.set

            永久有效的方法:
                varnish.params
                    DEAMON_OPTS="-p PARAM1=VALUE -p PARAM2=VALUE"

实例:
102.70:varnish
vim /etc/varnish/varnish.params

Other options, see the man page varnishd(1) //默认注释

        DAEMON_OPTS="-p thread_pools=4 -p thread_pool_min=50 -p thread_pool_max=2000 -p thread_pool_timeout=300"

varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082
    param.set thread_pools 4
    200        

    varnish日志区域:
        shared memory log 
            计数器
            日志信息

        1、varnishstat - Varnish Cache statistics
            -1
            -1 -f FILED_NAME 
            -l:可用于-f选项指定的字段名称列表;

            MAIN.cache_hit 
            MAIN.cache_miss

            # varnishstat -1 -f MAIN.cache_hit -f MAIN.cache_miss
                显示指定参数的当前统计数据;
            # varnishstat -l -f MAIN -f MEMPOOL
                列出指定配置段的每个参数的意义;

        2、varnishtop - Varnish log entry ranking
            -1     Instead of a continously updated display, print the statistics once and exit.
            -i taglist,可以同时使用多个-i选项,也可以一个选项跟上多个标签;
            -I <[taglist:]regex>:对指定的标签的值基于regex进行过滤; 
            -x taglist:排除列表
            -X  <[taglist:]regex>:对指定的标签的值基于regex进行过滤,符合条件的予以排除;

        3、varnishlog - Display Varnish logs

        4、 varnishncsa - Display Varnish logs in Apache / NCSA combined log format

    内建函数:
        hash_data():指明哈希计算的数据;减少差异,以提升命中率;
        regsub(str,regex,sub):把str中被regex第一次匹配到字符串替换为sub;主要用于URL Rewrite
        regsuball(str,regex,sub):把str中被regex每一次匹配到字符串均替换为sub;
        return():
        ban(expression) 
        ban_url(regex):Bans所有的其URL可以被此处的regex匹配到的缓存对象;
        synth(status,"STRING"):生成响应报文;

总结:
    varnish: state engine, vcl 
        varnish 4.0:
            vcl_init 
            vcl_recv
            vcl_hash 
            vcl_hit 
            vcl_pass
            vcl_miss 
            vcl_pipe 
            vcl_waiting
            vcl_purge 
            vcl_deliver
            vcl_synth
            vcl_fini

            vcl_backend_fetch
            vcl_backend_response
            vcl_backend_error 

        sub VCL_STATE_ENGINE {
            ...
        }
        backend BE_NAME {} 
        probe PB_NAME {}
        acl ACL_NAME {}

转载于:https://blog.51cto.com/001230/2151263

 类似资料: