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

Varnish缓存

栾弘新
2023-12-01

Web Page Cache:

squid --> varnish

程序的运行具有局部性特征:
    时间局部性:一个数据被访问过之后,可能很快会被再次访问到;
    空间局部性:一个数据被访问时,其周边的数据也有可能被访问到

cache:命中 

    热区:局部性;
        时效性:
            缓存空间耗尽:LRU,最近最少使用;
            过期:缓存清理

缓存命中率:hit/(hit+miss)
    (0,1)
    页面命中率:基于页面数量进行衡量
    字节命中率:基于页面的体积进行衡量

缓存与否:
    私有数据:private,private cache;
    公共数据:public, public or private cache;

Cache-related Headers Fields
    The most important caching header fields are:

        Expires:过期时间;
            Expires:Thu, 22 Oct 2026 06:34:30 GMT
        Cache-Control:max-age=

        Etag
        If-None-Match

        Last-Modified
        If-Modified-Since

        Vary:缓存的数据可能包含格式的转换,如压缩
        Age

    缓存有效性判断机制:
        过期时间:Expires
            HTTP/1.0
                Expires:过期
            HTTP/1.1
                Cache-Control: maxage=
                Cache-Control: s-maxage=
        条件式请求:
            Last-Modified/If-Modified-Since:基于文件的修改时间戳来判别;
            Etag/If-None-Match:基于文件的校验码来判别;

        Expires:Thu, 13 Aug 2026 02:05:12 GMT
        Cache-Control:max-age=315360000
        ETag:"1ec5-502264e2ae4c0"
        Last-Modified:Wed, 03 Sep 2014 10:00:27 GMT

    缓存层级:
        私有缓存:用户代理附带的本地缓存机制;
        公共缓存:反向代理服务器的缓存功能;

        User-Agent <--> private cache <--> public cache <--> public cache 2 <--> Original Server

        Cache-Control: key=value, key=value

请求报文用于通知缓存服务如何使用缓存响应请求:
    cache-request-directive = 
        "no-cache",                        
        | "no-store"                         
        | "max-age" "=" delta-seconds        
        | "max-stale" [ "=" delta-seconds ]  缓存倒计时不得少于多少时间,stale陈旧的
        | "min-fresh" "=" delta-seconds      
        | "no-transform"                    
        | "only-if-cached"                  
        | cache-extension                    

响应报文用于通知缓存服务器如何存储上级服务器响应的内容:
    cache-response-directive =
        "public"                               
        | "private" [ "=" <"> 1#field-name <"> ] 
        | "no-cache" [ "=" <"> 1#field-name <"> ],可缓存,但响应给客户端之前需要revalidation,即必须发出条件式请求进行缓存有效性验正;
        | "no-store" ,不允许存储响应内容于缓存中;                           
        | "no-transform"                        
        | "must-revalidate"                     
        | "proxy-revalidate"                  
        | "max-age" "=" delta-seconds           私有缓存和公共缓存都有效
        | "s-maxage" "=" delta-seconds          主要控制公共缓存
        | cache-extension     

开源解决方案:
    squid(章鱼即八爪鱼):旧的缓存软件,但是稳定
    varnish:
    squid之于varnish相当于apache之于nginx
    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 读取combined格式的日志
日志持久的服务;

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

        · malloc[,size]
            内存存储,[,size]用于定义空间大小;重启后所有缓存项失效;
        · file[,path[,size[,granularity]]]  

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    列出vcl配置文件,active表示当前正在使用此配置文件
        param.show [-l] [<param>]   列出所有可调整参数
        param.set <param> <value>
        panic.show
        panic.clear
        storage.list
        vcl.show [-v] <configname>  查看指定的默认的配置文件,不加-v是指定的配置文件
        backend.list [<backend_expression>]
        backend.set_health <backend_expression> <state>
        ban <field> <operator> <arg> [&& <field> <oper> <arg>]...
        ban.list    匹配正则表达式进行清除

        配置文件相关:
            vcl.list 
            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 */    SPDY是google的http加

速协议;
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 { ...};
        (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
        (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是内建变量,用于保存某缓存项的从缓存中命中的次数;
            if (obj.hits>0) {
                set resp.http.X-Cache = "HIT via" + " " + server.ip;
            } else {
                set resp.http.X-Cache = "MISS from " + server.ip;
            }

    变量类型:
        内建变量:
            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:请求方法;
                    bereq.url:请求的url;
                    bereq.proto:请求的协议版本;
                    bereq.backend:指明要调用的后端主机;

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

                beresp.*, resp.*:
                    beresp.http.HEADERS
                    beresp.status:响应的状态码;
                    reresp.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)") {  ?表示flag标志位引导,i表示ignore忽略字符

大小写;
return(pass);
}
}

    示例2:对于特定类型的资源,例如公开的图片等,取消其私有标识,并强行设定其可以由varnish缓存的时长; 定义在vcl_backend_response中;
        if (beresp.http.cache-control !~ "s-maxage") {
            if (bereq.url ~ "(?i)\.(jpg|jpeg|png|gif|css|js)$") {
                unset beresp.http.Set-Cookie;
                set beresp.ttl = 3600s;
            }
        }

    示例3:定义在vcl_recv中;
        if (req.restarts == 0) {    restarts是在更改url请求后进行以将请求返回到recev重新进

行检查;重启后restarts变成1,继续重启变成2
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;
}
}
实验:在varnish上设置不允许访问login私密数据
vim default.vcl
backend default { #配置后端主机,并改变端口为80以方便访问
.host = "172.18.62.63";
.port = "80";
}

sub vcl_recv { #设置接收到访问http://172.18.62.61/login/的请求后不走缓存
if (req.url ~ "^/login" ) {
return(pass);
} #注意要选择好适合的状态引擎
varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082 进入管理界面
vcl.load test2 default.vcl 加载配置,相当于转换-->编译
vcl.use test2 将编译好的文件触发交给几个进程处理
vcl.list 查看是否在使用test2
缓存对象的修剪:purge, ban
(1) 能执行purge操作
sub vcl_purge {
return (synth(200,"Purged"));
}

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

        添加此类请求的访问控制法则:
            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);
                }
                ...
            }
            curl -X PURGE http://127.0.0.1/test2.html   -X指定浏览器用PURGE方法进行

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

                示例:
                    ban req.url ~ ^/javascripts

            (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"));
                }   

                ban req.http.host==www.ilinux.io && req.url==/test1.html
                建议随用随运行;
                http://www.ilinux.io/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;
            }   

            ...
        }

    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);
            }       #由于没有设置cookie,故而此调度不生效      

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

        .probe:定义健康状态检测方法;
            .url:检测时要请求的URL,默认为”/"; 
            .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.set_health srv1 sick
backend.set_health srv1 healthy
backend.set_health srv1 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. 额外意义为“最大空闲线程数”;
            param.show thread_pools 显示线程池信息
param.set thread_pools 4    设置线程池的线程数量
                最大并发连接数 = 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.
            指的是varnishadm管理连接超时时长;
            设置方式:
                vcl.param 
                param.set

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

    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选项,也可以一个选项跟上多个标签;
例子:varnishtop -i ReqURL
-I <[taglist:]regex>:对指定的标签的值基于regex进行过滤;
例子:varnishtop -I login
-x taglist:排除列表
例子:
varnishtop -x ReqURL
varnishtop -I HTTP/1
-X <[taglist:]regex>:对指定的标签的值基于regex进行过滤,符合条件的予以排
除;

        3、varnishlog - Display Varnish logs 是实时显示日志,已有的日志不会读取

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

5、systemctl restart varnishncsa 启动此服务为守护进程以将内存中的日志实时记录
到磁盘文件中;实际上运行的是此/usr/lib/systemd/system/varnishncsa.service服
务;
内建函数:
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 {}

博客作业:以上所有内容; 
    实战项目:两个lamp部署wordpress,用Nginx反代,做压测;nginx后部署varnish缓存,调     

整vcl,多次压测;

    ab, http_load, webbench, seige, jmeter, loadrunner,...

补充资料:varnish book
http://book.varnish-software.com/4.0/

示例:
backend imgsrv1 {
.host = "192.168.10.11";
.port = "80";
}

backend imgsrv2 {
    .host = "192.168.10.12";
    .port = "80";
}   

backend appsrv1 {
    .host = "192.168.10.21";
    .port = "80";
}

backend appsrv2 {
    .host = "192.168.10.22";
    .port = "80";
}

sub vcl_init {
    new imgsrvs = directors.random();
    imgsrvs.add_backend(imgsrv1,10);
    imgsrvs.add_backend(imgsrv2,20);

    new staticsrvs = directors.round_robin();
    appsrvs.add_backend(appsrv1);
    appsrvs.add_backend(appsrv2);

    new appsrvs = directors.hash();
    appsrvs.add_backend(appsrv1,1);
    appsrvs.add_backend(appsrv2,1);     
}

sub vcl_recv {
    if (req.url ~ "(?i)\.(css|js)$" {
        set req.backend_hint = staticsrvs.backend();
    }       
    if (req.url ~ "(?i)\.(jpg|jpeg|png|gif)$" {
        set req.backend_hint = imgsrvs.backend();
    } else {        
        set req.backend_hint = appsrvs.backend(req.http.cookie);
    }
}
注意:

1、nginx和haproxy调度器是基于7层调度的,是和早期http协议有关的调度;
2、用户的请求和并发数并不是一一对应的关系,因为一个客户端可以同时生成多个线程进
行访问,构成多个并发。
3、IAAS:基础架构机服务,如购买个一小时的虚拟机进行软件测试
4、PAAS:平台级服务,不仅有虚拟机,虚拟机里面还运行相应的软件
5、SAAS:软件级服务,用浏览器打开应用,进行云软件使用,如微软的word
6、浏览器私有缓存、公共缓存
7、依据缓存28法则,20%的缓存承载80%的需求,如果用静态缓存,那么当缓存机器出问
题时,会使得缓存消失,那么后端机器会瞬间雪崩,并且再次启动服务时,通过健康性检查
后,再次涌入大量访问,会使服务机器再次崩溃,要解决此需要限流或将上一层移除启动或
进行缓存机器的预热缓存数据;因此使用动态缓存比较好;
8、kv数据是将数据结构缓存到内存中,一次性查找即可找到缓存数据
9、CDN是内容分发网络,是建立的各个区域的缓存服务器(放到用户“家门口”)的集合,对
于小公司可以购买这一服务;要买双份的,防止意外发生,但是按流量收费,价格也不便
宜;
10、GLSB:全局负载均衡,即全局调度
11、fastcgi协议不能直接用haproxy进行调度,因为需要客户端也发出fastcgi请求才可以,但
是客户端并没有发fastcgi协议的请求;一般而言是先调度到nginx,然后由nginx转给fastcgi
的PHP程序;shift+F5是强制刷新;
12、缓存具有空间上和时间上的局限性。
13、ttl:time to live 存活周期;对缓存的内容进行ttl控制,如果在控制有效时,后端服务器
内容进行了更新,那么缓存就相当于过期了,这时需要缓存管理员进行cache purge内容清
除,以避免用户访问到的都是旧的数据;http1.0版本的缓存控制太过于粗暴,而http1.1的缓
存控制机制有所改进,使用了条件式的访问,用户请求到达缓存服务器后没有缓存就调度到
后端服务器,有缓存就问后端服务器在此缓存时间后是否有更新;但是有缺点,如更新很频
繁的话有毫秒级的更新,这就不能依据此进行,而应该在缓存时随机打一个版本号(if none
match),当数据更新后,后端数据版本发生变化,这就解决了依靠时间戳判断的问题;但
是这样的话,用户访问效率降低;因此,采用两者结合的做法,在设置了缓存后,在缓存不
过期的时间内对访问时,直接调度缓存服务器上的内容,而不会与后端服务器进行交互,在
缓存过期后,先通过缓存问后端服务器的数据是否更新了,如果没有更新那么继续从缓存服
务器上取内容,如果更新了再从后端服务器进行内容调度;还可以缓存管理员进行purge
cache或ban(正则表达式匹配清除)
14、Varnish Architecture

注意:里面的各个进程各自起自己的作用;2个接口,一个用来管理接口的,一个提供应
用;分别使用6082端口和6081端口;是递归式缓存;配置使用c语言起作用,如果不是c语
言就使用VCL进行转换;日志为了避免存储到磁盘降低性能,是先在内存中找一块固定空
间,然后将日志放进去,如果空间满了就进行覆盖,需要日志就人工导出到磁盘;日志分为
两个部分,统计部分和日志部分,统计部分不会被覆盖;CLI interface是varnish的管理接
口;VAC是一个付费的图形界面管理接口;
旁挂式缓存:是客户端到缓存找,没有就不是缓存服务器代理访问后端服务器,而是客户端
自己这访问后端服务器;VCL是动态加载的。
15、缓存机制:
内存存放:机器一重启就丢失
磁盘存放:是在磁盘中放一个二进制文件,此二进制文件内部定义有文件系统,对
外是不可见的,一旦机器重启,缓存就会丢失。提倡参数运行时修改
持久磁盘缓存:重启后缓存不会丢失,但是4.0版本的varnish是不能使用此功能的
16、配置文件是通过命令行参数来实现的;而缓存的参数是不能当做配置文件的,故而通过
环境变量文件进行调用;cat /usr/lib/systemd/system/varnish.service;
17、如果从客户端发来的请求不能被应用层识别,那么varnish就自动将请求降为4层模式转
发到后端服务器,不分析应用层首部,称为管道;从varnish缓存发到服务器中间要经过一个
状态引擎;
18、VCL是一个预专有配置,一段配置只能适用于一个引擎;当接到用户的请求时,如果要
访问缓存,那么就看uri的哈希值是否有。

19、Variable availability in VCL

转载于:https://blog.51cto.com/angwoyufengtian/2126389

 类似资料: