缓存服务器memcached和varnish

两类缓存服务器：
1.代理式缓存服务器；proxy-like cache server；
2.旁挂式缓存服务器；bypass cache server；

缓存服务器也能够根据缓存数据内容分类：
    1.数据缓存；data cache
    2.页面缓存；page cache

数据存在访问热区，指被常常访问的数据。

缓存的实质是：用空间换时间；
缓存的局部性特征：空间局部性和时间局部性：

缓存的时效性：
过时清理：PURGE，修剪；
未过时但溢出清理：LRU（最少使用原则）；
未过时但被修改：PURGE，修剪；

缓存命中率：Hits/(Hits + Miss) ，取值范围区间是(0,1)，一般也会用百分数进行表示；
页面命中率：基于命中的页面数量进行统计衡量的一种标准；
字节命中率：基于命中的页面的体积进行统计衡量的一种标准；（更为精确）

数据缓存与否：
1.私有数据：private data，放置于私有缓存中；
http/1.1版本后的首部中，提供了一个Cach-Control的首部；Cache-Control首部的值中包含有private字样，或者提供了Cookie或者Cookie2的首部；此类数据大多数都是由浏览器完成缓存；
2.公共数据：public data，能够放置于公共缓存，也能够放置于私有缓存中；
此类数据大多数缓存在反代服务器上或者专用的Cache Server上；
小部分也能够缓存在浏览器上；

注意：
    浏览器的缓存（通常是私有缓存）：
        仅针对于单独的用户生效，使用户重复访问某资源时可以加速访问；
    缓存服务器的缓存（通常是公共缓存）：
        为前端调度器或反代服务器加速资源访问，下降后端资源服务器的访问压力；

对于缓存服务器来讲，缓存的处理步骤（大体成功的处理步骤）：
接收请求 --> 解析请求(从请求报文的http协议首部中提取URL及其余相关的首部信息) --> 查询缓存 --> 缓存数据的新鲜度检测 --> 构建响应报文 --> 发送响应报文--> 记录日志

缓存数据的有效性判断机制：
1.过时时间：
HTTP/1.0：
Expires，绝对时间；
HTTP/1.1：
1.Expires
2.Cache-Control（首部）：max-age=86400
3.Cache-Control：s-maxage=10000 （s表明公共缓存）
2.条件式请求：
Last-Modified/If-Modified-Since ：响应报文/请求报文的条件请求
Etag/If-None-Match ：扩展标签，对标签进行哈希计算；If-None-Match：若是不匹配，返回200表明不匹配

示例：查看百度的logo资源：
Cache-Control max-age=2592000 //缓存资源的最大有效时间
ETag "593645fd-664" //获得的16进制的哈希值
Expires Wed, 11 Jul 2018 03:43:28 GMT //过时时间
Last-Modified Tue, 06 Jun 2017 06:04:45 GMT //自 06 Jun 2017 06:04:45 GMT这个时间点开始资源无变化（GMT：格林尼治时间）

1、memcached缓存服务器：
属于旁挂式缓存服务器，也属于数据缓存；

memcached存储形式：
    1.将全部数据采用键值对儿的形式存储于内存当中；
    2.无持久存储功能；
    3.一般用于缓存小文件，小数据，单项缓存数据内容上限是1MB；

memcached由LiveJournal公司旗下的子公司Danga Interactive研发者Brad Fitzpatrick研发；

memcached特性：
    1.k/v cache；可序列化数据，扁平化数据；         //常见的还有JSON，也是序列化数据
    2.存储项：key（键）, value（值）, flag（16位二进制数字，0-65535）, expire_time（超时时间）, length（保存数据的长度）等简单部分组成；
    3.旁挂式缓存，功能实现一半依赖于客户端，另外一半靠memcached server；
    4.O(1)的查找和执行效率；
    5.能够构建分布式缓存系统，各服务器之间互不通讯的分布式集群系统；
    6.缓存数据的处理方式（较为特殊）：
        1）缓存空间耗尽：根据LRU（最近最少使用算法）完成清理过时数据；
        2）缓存项过时：惰性清理机制---用来尽量减小内存碎片
    7.内存分配方式：
        slab allocation：按照页面进行打散，将打散的页面分红若干个更小的页面，最大1M
            facter：增加因子；默认1.25倍递增；小页面根据增加因子来分配空间大小，最后会留下一个最大不超过1M的空间。

安装配置memcached：
    1.base源中有对应的rpm包；能够直接使用yum方式安装内容；
            ~]# yum install memcached -y
    2.从memcached.org官方站点下载源代码包，编译安装；

    memcached缓存服务监听的端口：
        11211/TCP, 11211/UDP；

    memcached缓存服务程序安装后的默认环境：
        主程序：/usr/bin/memcached
        环境配置文件：/etc/sysconfig/memcached
            ~]# cat /etc/sysconfig/memcached 
            PORT="11211"        //监听的端口号
            USER="memcached"    //程序属于哪一个用户
            MAXCONN="1024"      //服务的最大链接数
            CACHESIZE="64"      //缓存大小默认为64
            OPTIONS=""                  //其余选项默认为空

    memcached缓存服务使用的协议是memcached协议，memcached协议支持的数据传输格式是：
        1.文件格式
        2.二进制格式

    交互式操做（~]# telnet+载有memcached服务主机的IP地址+端口号（默认是11211），使用telnet命令进入交互式操做模式）：
        命令：
            1.统计类：stats, stats items（缓存项查看）, stats slabs（内存空间的查看）, stats sizes
            2.管理类：set（修改特定键的值）, add（添加一个新的键）, replace（替换原有键的值）, append（在原有键值后附加一个值）, prepend（在原有键值前附加一个值）, delete（删除键）, incr（给键添加值）, decr（给键删除值）, flush_all（清空全部键）
            3.查看类：get

        memcached交互式命令的通常格式：
            <command> key_name [flags] [expire_time] [length_bytes] \n

             key_name：键名
             [flags]：标志位，范围是0-65535
             [expire_time]：键最大缓存时间（秒）
             [length_bytes]：字符长度

            例:
                添加一个新键：
                    add testkey 0 300 11
                    hello world
                    STORED
                查看新键：
                    get testkey
                    VALUE testkey 0 11
                    hello world
                    END
                在新键后添加字符并查看：
                    添加：
                        append testkey 0 300 2
                        hi
                        STORED
                    查看：
                        get testkey
                        VALUE testkey 0 13
                        hello worldhi
                        END
                在新键前添加字符并查看：
                    添加：
                        prepend testkey 0 300 3
                        hi 
                        STORED
                    查看：
                        get testkey
                        VALUE testkey 0 14
                        hi hello world
                        END

    memcached命令选项：
        -c num ：指名并发链接数量，默认是1024
        -m num ：分配多大的内存空间，默认是64M
        -u username ：指定哪一个用户启动memcached服务进程
        -p port ：指定端口号，默认是11211
        -U port ：指定UDP协议的端口号，默认是11211,0是关闭
        -l ipaddress ：监听哪个地址，默认是全部
        -f facter ：指明增加因子，默认是1.25倍
        -t thread_num ：设置线程数，默认是4个线程
        -v,-vv,-vvv ：显示的详细信息程度

2、VARNISH缓存服务器：
varnish缓存服务器是属于页面缓存服务器的一种，用来为客户端请求提供查询结果，也属于代理式缓存服务器。

varnish缓存服务器特色：
    varnish缓存服务器能够实现的功能：反向代理 + 缓存服务器
    varnish缓存服务器默认在内存中占用128M内存空间去进行缓存服务

缓存服务器的实现：
开源解决方案：
squid：上世纪90年代中期出现；使用率较低
varnish：反向代理式缓存：使用率较高的缓存服务器实现方案；
https://www.varnish-software.com/ //商业版本服务站点
http://varnish-cache.org/ //开源站点

varnish程序的组织结构：
        1.Management进程：
                     1）varnish的主进程；
                     2）提供命令行工具的访问接口，用来管理子进程，初始化缓存；
        2.Child/Cache进程：拥有多种线程模型，以下：
                    command line
                    storage/hashing
                    log/stats
                    accept
                    worker threads
                    object expiry
                    backend communication
                    ...
        3.VCL compiler：C compiler(gcc)

varnish的线程池做用：
    统计数据：数据统计和计数器；
    日志区域：日志数据；

VCL文件的处理方式：
    vcl compiler （vcl编译器编译完成）--> C compiler （再到C的编译器中编译处理）--> shared object

vcl配置文件的重载工具：
        /usr/sbin/varnish_reload_vcl

VCL：Varnish Configuration Language，varnish配置语言；
统一存放于后缀名为".vcl"的文件中，在初次安装了varnish以后，在配置主目录中会自动建立出一个名为"default.vcl"的文件，但其内容几乎为空；

varnish的安装：
在EPEL源中直接提供了varnish的稳定版本；
安装命令：yum install -y varnish （需先配置EPEL源）

varnish的程序环境：
    1.配置文件：
        /etc/varnish/default.vcl
            定义缓存策略的默认配置文件，主要用于配置各Child/Cache线程的工做属性；
        /etc/varnish/varnish.params
            定义varnish缓存服务的运行时参数以及工做特性；
        /etc/varnish/secret
            在使用varnishadm命令行管理工具时，为了安全起见使用的预共享密钥；

    2.主程序：  /usr/sbin/varnishd

     1）CLI（简单的命令行接口管理工具）：
        /usr/bin/varnishadm

     2）Share Memory Log交互工具：
        /usr/bin/varnishhist
        /usr/bin/varnishlog
        /usr/bin/varnishncsa
        /usr/bin/varnishstat
        /usr/bin/varnishtop

                开启varnish日志记录（默认没有开启）：
                    1./usr/bin/varnishlog
                    2./usr/bin/varnishncsa（建议在须要开启日志记录的时候开启，由于其更接近于Apache的command的命令形式）

    3）缓存测试工具：
        /usr/bin/varnishtest

    4）varnish的Unit FIle：
        /usr/lib/systemd/system/varnish.service：管理varnish的Management进程；
        实现日志持久化存储的服务文件；
            /usr/lib/systemd/system/varnishlog.service
            /usr/lib/systemd/system/varnishncsa.service

主程序：/usr/sbin/varnishd
    varnishd - HTTP accelerator daemon  --http加速器守护进程
        经常使用选项：
            -a address[:port][,address[:port][...]
                指定用于接收客户端请求所监听的地址和服务端口，默认值为127.0.0.1:6081
            -b host[:port]：添加一个backend sever的主机和端口号
            -T address[:port]：实现管理的时候须要用到的地址和端口号；
            -f config：
                指明这次须要编译并装载的VCL配置文件，默认为/etc/varnish/default.vcl；
            -p param=value
                设置varnish线程模型的运行时参数和参数值；
                大多数的运行时参数都有默认值，不要轻易尝试调整运行时参数的值；
                在命令行工具中使用此选项调整的运行时参数的值，仅当次生效；
            -r param[,param...]
                将运行时参数设置为只读属性；意味着当再次运行时，其值没法被修改；
            -s [name=]type[,options]：指定缓存的存储机制
                定义缓存数据的存储方式，目前有三种存储机制：
                    1.malloc[,size]：性能最好，可是全部的数据保存在内存中；
                    2.file[,path[,size[,granularity]]]：只是一种黑盒文件，内容没法观察；键值对儿存放于内存当中，哈希值存放于磁盘中，保证快速检索，不会占用内存太多空间
                    3.persistent,path,size (experimental，体验测试版)：持久存储（机制不成熟）

            -T address[:port]
                在指定的IP地址和端口号上提供管理接口；默认为127.0.0.1:6082；
            -u user、-g group
                指定容许varnish服务进程的系统用户和系统组，默认均为varnish；

    运行时参数的配置文件：/etc/varnish/varnish.params
        DAEMON_OPTS="-p param1=value1 -p param2=value2 ..."

        thread_pool_min=5
        thread_pool_max=500
        thread_pool_timeout=300

命令行管理工具：varnishadm （交互式模式）
    varnishadm - Control a running Varnish instance
        经常使用选项：
            -S secret_file
                指定经过命令行工具实现验证时的预共享密钥文件；
            -T address:port
                指定管理地址和端口；

    交互式模式的命令：
        help [<command>] ：varnishadm命令帮助
        ping [<timestamp>] ：作连通测试
        auth <response> :作认证
        quit ：退出交互式模式
        banner ：作条幅
        status ：状态输出
        start ：启动varnish服务（不建议使用）        //重启、关闭、开启都会把缓存清空，这是致命的
        stop ：关闭varnish服务（不建议使用）
        管理vcl：
            vcl.load <configname> <filename>：装载而且编译vcl文件
            vcl.inline <configname> <quoted_VCLstring>：
            vcl.use <configname>：激活已经编译好的vcl文件；
            vcl.discard <configname>：删除已经编译好的非激活状态下的vcl配置文件；
            vcl.list：vcl配置文件一共有哪些；
        param.show [-l] [<param>]：列举全部运行时参数而且输出详细参数；
        param.set <param> <value>：临时修改某个运行时参数的值，一次性修改，重启后恢复默认
        panic.show：显示运行时参数列表或显示指定的运行时参数的详细信息；
        panic.clear：清空运行时参数列表；
        storage.list：显示缓存存储相关信息；
        vcl.show [-v] <configname> ：显示default.vcl全部配置历史更改列表，包括正在使用和使用过的；
        backend.list [<backend_expression>] ：后端服务器列表显示；
        backend.set_health <backend_expression> <state> ：设置后端服务器将康状态码；

经常使用的命令：
    VCL配置文件管理相关：
        vcl.load：装载并编译VCL配置文件；
        vcl.use：激活已经编译完成的VCL配置文件；
        vcl.discard：删除非激活状态下的VCL配置文件；

    运行时参数相关：
        param.show：显示运行时参数列表或显示指定的运行时参数的详细信息；
        param.set：实时设置或修改运行时参数的值；（不要轻易尝试修改，必定要清楚操做的目的）

    缓存存储相关：
        storage.list：显示缓存存储相关信息；

    后端服务器相关：
        backend.list：显示能够直接访问的后端服务器列表；
        backend.set_health：指明后端服务器的健康状态检测方式；

VCL：Varnish Configuration Language；
    "域"专有类型的配置语言；

    VCL中定义了多个状态引擎，各状态引擎之间存在相关性，同时又彼此隔离；每一个状态引擎内均可以使用return()关键字指明各状态引擎之间的关联关系；在VCL文件中，状态引擎使用以下的方式进行定义：
        sub STATE_ENGINE_NAME { ...; }
        sub+状态引擎的名字+{ 配置指令1;配置指令2;... }

三个varnish状态引擎版本对比以及数据处理流程：
1.varnish 2.0-状态引擎包括：
vcl_recv：接收请求，而且判断是否可使用缓存数据；
vcl_hash：对于从backend端取回的数据，若是可被缓存，则进行哈希计算；
vcl_hit：对于请求的资源能够在缓存对象中直接获取；
vcl_miss：对于请求的资源没法在缓存对象中直接获取；
vcl_deliver：构建响应报文；
vcl_fetch：从backend端取回数据；

varnish2.0的处理流程：
            1.vcl_recv --> vcl_hash --> vcl_hit --> vcl_deliver
            2.vcl_recv --> vcl_hash --> vcl_miss --> vcl_fetch --> vcl_deliver
            3.vcl_recv --> vcl_fetch --> vcl_deliver （不走缓存）

    2.varnish 3.0状态引擎包括：
        vcl_recv：接收请求，而且判断是否可使用缓存数据；
        vcl_hash：对于从backend端取回的数据，若是可被缓存，则进行哈希计算；
        vcl_hit：对于请求的资源能够在缓存对象中直接获取；
        vcl_miss：对于请求的资源没法在缓存对象中直接获取；
        vcl_deliver：构建响应报文；
        vcl_fetch：从backend端取回数据；
        较varnish2.0新增：
            vcl_pass：对于原本能够从缓存中查找到资源明确的设置不使用缓存；多数用于私有缓存的查找策略；
            vcl_pipe：对于没法理解的请求，直接按照原样的封装直接代理至backend端；
            vcl_error：本地发生错误时，构建错误响应报文；

        varnish的处理流程：
            1.vcl_recv --> vcl_hash --> vcl_hit --> vcl_deliver
            2.vcl_recv --> vcl_hash --> vcl_hit --> vcl_pass --> vcl_fetch -->vcl_deliver
            3.vcl_recv --> vcl_hash --> vcl_miss --> vcl_fetch --> vcl_deliver
            4.vcl_recv --> vcl_hash --> vcl_miss --> vcl_pass --> vcl_fetch --> vcl_deliver
            5.vcl_recv --> vcl_pass --> vcl_fetch --> vcl_deliver
            6.vcl_recv --> vcl_pipe

    3.varnish 4.0+状态引擎包括：
        vcl_recv：接收请求，而且判断是否可使用缓存数据；
        vcl_hash：对于从backend端取回的数据，若是可被缓存，则进行哈希计算；
        vcl_hit：对于请求的资源能够在缓存对象中直接获取；
        vcl_miss：对于请求的资源没法在缓存对象中直接获取；
        vcl_deliver：构建响应报文；
        vcl_pass：对于原本能够从缓存中查找到资源明确的设置不使用缓存；多数用于私有缓存的查找策略；
        vcl_pipe：对于没法理解的请求，直接按照原样的封装直接代理至backend端；
        较于varnish3.0新增：
            vcl_backend_fetch：从backend端取回数据；
            vcl_backend_response：处理从backend取回的数据；
            vcl_backend_error：本地发生错误时，构建错误响应报文；
            vcl_synth：主要用于缓存修剪及信息发送；（由varnish3.0中的error变化而来）
            vcl_purge：修剪缓存；

        varnish的处理流程：
            1.vcl_recv --> vcl_hash --> vcl_hit --> vcl_deliver
            2.vcl_recv --> vcl_hash --> vcl_hit --> vcl_pass --> vcl_backend_fetch --> vcl_backend_response --> vcl_deliver
            3.vcl_recv --> vcl_hash --> vcl_pass --> vcl_backend_fetch --> vcl_backend_response --> vcl_deliver
            4.vcl_recv --> vcl_hash --> vcl_miss[ --> vcl_pass ] --> vcl_backend_fetch --> vcl_backend_response --> vcl_deliver
            5.vcl_recv --> vcl_hash --> vcl_purge --> vcl_synth
            6.vcl_recv --> vcl_hash --> vcl_pipe
            7.vcl_recv --> vcl_hash --> waiting
                                                                    ↑                                   ↓
                                                                     ←←←←←

        varnish中还有两个特殊的状态引擎：
            vcl_init：
                在处理任何请求以前要调用此引擎，主要用于初始化VMODs；
            vcl_fini：
                在全部的请求都已经处理结束，在VCL的配置被丢弃时调用此引擎，主要用于清理VMODs；

VCL的语法格式：
    1.与C、C++语言的语法很是类似，能够支持C、C++或perl风格的注释方式：
        //, #, /* ... */
    2.VCL不支持循环和跳转语句；但能够是if条件分支(单分支、双分支及多分支)；
        if的单分支格式：
            if (condition) {
                ...;
            }
        if的双分支格式：
            if (condition) {
                ...;
            } else {
                ...;
            }
        if的多分支格式：
            if (condition1) {
                ...;
            } elseif (condition2) {
                ...;
            } else {
                ...;
            }
    3.全部的字符串内容应该放置于""以内，且不能使用换行符；
    4.支持内建和自定义的ACL；
    5.支持丰富的操做符：=（赋值符号）, ==（等值比较）, >, >=, <, <=, !, &&（与运算）, ||（或运算）, ~
    6.使用return()关键字来决定下一个处理流程使用哪一个引擎，且return()关键字无返回值；
    7.支持内建变量及自定义变量，而且内建变量之间存在依赖关系，只能在特定的引擎中调用特定的内建变量；
        set var_name = value
        unset var_name

VCL中的内建变量：
    req.*：request，表示客户端发送来的请求报文相关的变量；
    bereq.*：backend request，由varnish向backend端主机发送请求的相关变量；
    resp.*：response，由varnish响应给前端设备或客户端的响应报文的相关变量；
    beresp.*：backend response，由backend主机响应给varnish的响应报文的相关变量；
    obj.*：存在在缓存空间中的缓存对象相关的变量，只读；

    经常使用的内建变量：
        req类：
            req.http.HTTP_HEADER_NAME：
                req.http.Cache-Control
                req.http.User-Agent
                req.http.Host：
                ...
            req.url：客户端发送来的请求报文中的URL相关信息；
                if (req.url ~ (?i)\.php$) {
                    return(pass);
                }
            req.method：客户端发送来的请求报文中的请求资源的方法；
            req.proto：客户端发送来的请求报文中使用的http协议版本；

        bereq类：
            bereq.http.HTTP_HEADER_NAME：
                bereq.http.Cache-Control
                bereq.http.User-Agent
                bereq.http.Host：

            bereq.url：varnish向backend端发送的请求报文中的URL相关信息；
            bereq.method：varnish向backend端发送的请求报文中的请求资源的方法；
            bereq.proto：varnish向backend端发送的请求报文中使用的http协议版本；
            bereq.backend：指明要调度的后端主机；

        resp类：
            resp.http.HTTP_HEADER_NAME：
            resp.status：varnish自身向客户端发送的响应报文中的响应状态码；
            resp.proto：varnish自身向客户端发送的响应报文中的http协议版本号；

        beresp类：
            beresp.http.HTTP_HEADER_NAME：
            beresp.status：backend端主机向varnish发送的响应报文中的响应状态码；
            beresp.proto：backend端主机向varnish发送的响应报文中的http协议版本号；
            beresp.backend.name：backend端主机型varnish发送的响应报文中的主机名；
            beresp.ttl：backend端主机响应的内容剩余的可缓存时长；

        obj类：
            obj.hits：指定的对象从缓存中命中的次数；(实时数值)
            obj.miss：指定的对象从缓存中未命中的次数；(实时数值)
            obj.ttl：指定的对象在缓存中剩余有效缓存时长；

VCL的自定义变量：
    定义变量：
        set VAR_NAME = VALUE;
    取消定义的变量：
        unset VAR_NAME;

为了方便展现下面的配置示例，说一下环境：
1.在安装好的varnish缓存服务器主机上，/etc/varnish/varnish.params中修改监听的后端服务器端口号为80而不是默认的6081，其余默认就能够，方便显示;
2.在/etc/varnish/varnish.params中VARNISH_LISTEN_PORT=80，而后保存退出重启服务（重启命令：systemctl reload varnish.service）
3.iptables -F关闭防火墙；
4.setenforce 0 更改SELinux的状态，防止访问受影响；

示例(1)：设置若是缓存命中则显示HIT，未命中显示MISS（作测试专用）：
在安装好的varnish缓存服务器主机上，/etc/varnish/default.vcl文件中配置以下内容：
#要显示在客户端，因此咱们要在构建响应报文中作配置即vcl_deliver
sub vcl_deliver {
#若是缓存服务器中缓存没有命中，obj.hits大于0便是缓存命中，在向客户端发送的响应报文中显示“HIT”，未命中则显示“MISS”
if (obj.hits>0) {
set resp.http.X-Cache = "HIT";
} else {
set resp.http.X-Cache = "MISS";
}
}
而且在/etc/varnish/default.vcl文件中添加一个后台服务器主机172.16.75.2（直接修改默认的backend default段就能够）：
#监听的端口号要和/etc/varnish/varnish.params中修改的保持一致
backend websrv1 {
.host = "172.16.75.2";
.port = "80";
}
运行时重载varnish服务，使其生效（也可使用交互式命令进入交互式模式:varnishadm -S /etc/varnish/secret -T 127.0.0.1:6082 ）：
~]#varnish_reload_vcl

在后端主机172.16.75.2上配置主页index.html中添加内容：Backend Server 7.5B
测试结果以下：
访问172.16.75.1获得的是172.16.75.2的主页

在响应报文中，显示第一次未命中MISS，第一次一定是MISS未命中，由于第一次缓存服务器和浏览器缓存中都没有咱们指望的缓存：

CTRL+F5不使用浏览器缓存，直接从服务器端取数据,以下，X-Cache显示HIT，下面的Pragma是no-cache，表示未使用浏览器端缓存（CTRL+F5刷新的结果）：

示例2：人为的设定对某特定资源的请求，不管缓存与否，强制其不检查缓存；
#在客户端请求报文中的URL若是匹配到“/test.html”字样，不在缓存服务器端取值直接向后端服务器取值（pass起到的做用）；
#仍然是在请求段配置需求；
#延续上面的配置段；
backend websrv1 {
.host = "172.16.75.2";
.port = "80";
}
#
sub vcl_recv {
if (req.url == "/test.html") {
return(pass);
}
#在客户端请求报文中的URL若是匹配到“/login”或“/admin”字样（(?i)表明不区分后边的字符大小写），不在缓存服务器端取值直接向后端服务器取数据
if (req.url ~ "(?i)^/(login|admin)") {
return(pass);
}
}
在172.16.75.2主机上/var/www/html/中建立test.html且建立目录admin/index.html，并添加内容方便测试，测试结果显示使用CTRL+F5刷新，X-Cache显示一直都是MISS，证实客户端直接从后端服务器中取数据，就算缓存服务器中存在数据也直接pass过直接去日后端服务器取数据：

访问admin目录主页，结果与预料一致，客户端直接从后端服务器直接获取数据：

示例3：对于某些特定类型资源，如：公开的图片，音频或视频流媒体资源，取消此类资源上的私有标识，并强制设定其能够由varnish进行缓存，且能够设定缓存时长；
#由于设定的是缓存服务器上的配置，因此这里是在后端服务器返回数据到缓存服务器段的配置；
sub vcl_backend_response {
#若是从后端服务器上返回的数据包括公共资源（s-maxage）和通用资源（max-age），再判断缓存服务器端向后端服务器请求的数据报文的URL中若是包括流媒体格式的文件，就取消此类资源上的私有标识并设定缓存时长；
if (beresp.http.Cache-Control !~ "(s-maxage|max-age)") {
if (bereq.url ~ "(?i).(jpg|jpeg|png|gif|mp4|mp3|js|css)$") {
unset beresp.http.Set-Cookie;
set beresp.ttl = 86400s;
}
}
}

示例4：缓存对象的修剪：purge，ban
#若是缓存服务器端收到客户端的请求带有指定的PUGER方法，则直接return到puger段，直接return到synth进行缓存修剪并返回一个状态码和一段信息；
sub vcl_recv {
if (req.method == "PURGE") {
return(purge);
}
}
#必须通过purge修剪状态引擎才能跳转到synth；
sub vcl_purge {
return(synth(200,"Cache Purged"));
}

测试方法：
curl -X PURGE http://172.16.75.1/

测试结果,与咱们设置的内容一致，状态码200等：![](https://s1.51cto.com/images/blog/201807/12/769cb5660d62f9d22e8969ad0b014c0b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

注意：修剪缓存对象的操做对于varnish来讲，可能形成很是大的影响；若是修剪不当或者是恶意修剪，可能会直接致使backend端压力剧增，甚至可能会出现故障，没法正常提供服务；

对于此类修剪缓存对象的操做，务必要作好访问控制法则：
更安全的缓存修剪策略示例：

#只容许本机修改
acl allowpurge {
"127.0.0.1";
}

设置修剪缓存的执行前提：
#若是客户端使用PURGE方法请求访问数据而且客户端IP不是缓存服务器本机，那咱们只好返回403状态码而且提示对方，若是是咱们本机则直接return到purge段进行缓存数据的修剪；
sub vcl_recv {
if (req.method == "PURGE") {
if (client.ip !~ allowpurge) {
return(synth(403,"Purge Forbidden for" + client.ip));
}
return(purge);
}
}

sub vcl_purge {
return(synth(200,"Cache Purged"));
}

测试结果：
首先咱们使用非本地主机(172.16.74.1)使用PURGE方法访问数据，以下结果：禁止访问

再使用本机(172.16.75.1)127.0.0.1进行访问，结果以下：显示正确的状态码，已经容许本机进行PURGE

acl的定义语法：
acl ACL_NAME {
"HOSTNAME";
"IP_ADDRESS";
"NETWORK_ADDRESS"/PREFIX
}

示例5：设定让Varnish可使用多个后端主机(Backend Server)；
#/etc/varnish/default.vcl文件中配置；
backend websrv1 {
.host = "172.16.75.3";
.port = "80";
}

backend appsrv1 {
.host = "172.16.75.4";
.port = "80";
}
#若是客户端请求的URL中包含以".php"结尾的信息，那么就把这个请求发给appsrv1，不然就把这个请求发给websrv1；
sub vcl_recv {
if (req.url ~ "(?i).php$") {
set req.backend_hint = appsrv1;
} else {
set req.backend_hint = websrv1;
}
}

在后端服务器主机172.16.74.1的/var/www/html/中添加一个以“.php”结尾的首页文件，进行测试访问：
]#vim index.php
7.4A PHP info page.<br>
<?php
phpinfo();
?>
开始测试，结果以下显示,能够经过URL来实现动静分离：

示例6：让vanish充当负载均衡集群的调度器，并对后端主机进行健康状态检测；
import directors;

backend websrv1 {
.host = "172.16.75.3";
.port = "80";
}

backend websrv2 {
.host = "172.16.75.4";
.port = "80";
}

sub vcl_init {
new websrvs = directors.round_robin();
websrvs.add_backend(websrv1);
websrvs.add_backend(websrv2);
}

sub vcl_recv {
if (req.url ~ "(?i).php$") {
set req.backend_hint = appsrv1;
} else {
set req.backend_hint = websrvs.backend();
}

if (req.url ~ "(?i)^/(login|admin)") {
  return(pass);
}

}

后端主机的健康状态检测：
backend websrv1 {
.host = "172.16.75.3";
.port = "80";
.probe = {
#.url = "/healthcheck"; //.url和.requset只能选一个，后者较为精准；
.timeout = 1s;
.interval = 2s;
.window = 5;
.threshold = 3;
.request =
"GET /healthcheck.html HTTP/1.1"
"Host: www.qhdlink.com"
"Connection: close";
.expected_response = 200;
}
}

说明：
.probe：定义开启对于指定的backend server进行健康状态检测；
.url：在执行健康状态检测时须要请求的URL，若是省略，默认为/；
.timeout：健康状态检测时被标识为失败的超时时间；
.interval：检测频率，即：多长时间进行一次健康状态检测；
.window：基于最近的多少次检测结果来判断后端主机的健康状态；
.threshold：阈值，在最近的.window次的检测中，至少应该有.threshold次是成功的，才会标识后端主机的健康状态为"healthy"或"Happy"；不然标识后端主机的监控状态为"sick"；
.request：对后端主机进行健康状态检测时发送的请求报文的具体内容；
.expected_response：对后端主机进行健康状态检测时，指望后端主机发送的响应报文中所包含的响应状态码，默认是200；

若是想要为多个backend设置统一的健康状态检测方法，能够事先定义健康状态检测方法，而后再在backend中引用此方法便可；

probe httpcheck {
.url = "/hc.html";
.timeout = 1s;
.interval = 2s;
.window = 5;
.threshold = 3;
}

backend websrv1 {
.host = "172.16.75.3";
.port = "80";
.probe = httpcheck;
}

backend websrv2 {
.host = "172.16.75.4";
.port = "80";
.probe = httpcheck;
}

分别在后端服务器172.16.75.2和172.16.74.1的/var/www/html/中设置一个健康状态监测网页hc.html,使用varnishadm交互模式进行测试：
两个后台都正常运行时：

关闭172.16.75.2后进行健康监测，结果以下：
[root@chenliang html]# systemctl stop httpd.service
下图显示，172.16.75.2已经sick：

上面就是健康测试机制。

varnish的运行时参数：
varnish的线程模型(Threads Model)：
cache-worker：用于处理从前端发送来的请求的线程模型；每一个请求都有一个该线程进行处理；
cache-main：用于管理和启动cache功能的线程模型；
ban lurker：用于实现基于正则表达式的模式匹配作缓存数据对象的修剪的进程模型；使用此类方式进行修剪时，不许确的正则表达式匹配规则有可能会对缓存对象形成误伤；
acceptor：用来接受新链接创建请求的线程模型；
epoll/kqueue：用于管理线程池，实现并发处理的线程模型；
expire：用于清理过时缓存数据对象内容的线程模型；
backend poll：用于对后端主机进行健康状态检测的线程模型；

运行时参数就是线程模型在运行时的工做参数；

经常使用的运行时参数：
    thread_pool_add_delay：每次建立新线程以前，所须要的延迟时间；默认为0s；
    thread_pool_destroy_delay：两次终止线程之间的延迟时间；默认为1s；
    thread_pool_fail_delay：在建立新线程失败以后，建立新线程以前的延迟时间，默认为0.2s；
    thread_pool_max：每一个线程池中能够激活的线程的最大数量；
    thread_pool_min：每一个线程池中能够保有的活跃线程的最小值；也能够理解为：每一个线程池中最大的空闲线程数量；
    thread_pool_timeout：对于那些超过thread_pool_min数量的全部的空闲线程的销毁的等待时间；
    thread_pools：定义了能够开启的线程池的最大数量，其值最好不要超过最大CPU核心数；

    在线程池的内部，每一个有前端发送来的请求都须要一个worker线程予以处理，varnish的并发处理能力：
        thread_pool * thread_pool_max

    vcl_dir
  Value is: /etc/varnish (default)
  Default is: /etc/varnish

  Directory from which relative VCL filenames (vcl.load and include) are opened.

    vmod_dir
        Value is: /usr/lib64/varnish/vmods (default)
  Default is: /usr/lib64/varnish/vmods

  Directory where VCL modules are to be found.

查看运行时参数：varnishadm命令行工具中查看：
查看全部运行时参数列表：
varnish> param.show -l
查看特定的运行时参数：
varnish> param.show PARAM_NAME

修改或设置运行时参数的值：
只读的运行时参数不能被修改；
实时修改，当即生效：
varnish> param.set PARAM_NAME VALUE

示例：
    varnish> param.set thread_pool_min 1000

非实时修改，但永久生效：
    /etc/varnish/varnish.params
        在这个文件中，若是在修改的选项中加入-r表明只读即不能在varnishadm中实时修改生效；

varnish的日志区域（内存中直接存储）：
shared memory log区域：
计数器；
日志信息；

varnish的日志查看和日志管理工具：
    1.varnishstat
        varnishstat - Varnish Cache statistics

        经常使用选项：
            -1：再也不连续的刷新显示varnish的状态信息，而是一次性的将即时的状态信息直接显示在标准输出；
            -f FIELD：显示指定的字段所表明的状态属性信息，一般与-1选项一同使用；字段描述时可使用通配符(*,?)；

            示例：
                varnishstat -1 -f MAIN.cache_hit
                varnishstat -1 -f MAIN.cache_miss
                varnishstat -1 -f MAIN.c*

    2.varnishtop
        varnishtop - Varnish log entry ranking

        经常使用选项：
            -1：再也不连续的刷新显示varnish的日志信息，而是一次性的将即时的日志信息直接显示在标准输出；
            -i taglist：选择仅显示指定标签所对应的属性信息，可使用","分隔多个标签，可使用多个-i选项显示，还可使用通配符；
                示例：
                    varnishtop -1 -i BereqMethod,ReqMethod
                    varnishtop -1 -i Bereq*
            -I [taglist:]regex：显示指定标签或全部标签的值中能够被"regex"所匹配的全部的日志信息；
            -x taglist：选择不显示指定标签所对应的属性信息，可使用","分隔多个标签，可使用多个-i选项排除对应的标签，还可使用通配符；
            -X [taglist:]regex：排除显示指定标签或全部标签的值中能够被"regex"所匹配的全部的日志信息；

    3.varnishlog
        varnishlog - Display Varnish logs

        注意：默认状况下vanish会将全部的varnish风格的日志信息记录于共享内存域中，若是想要将此类日志信息保存至文件系统中，CentOS系发行版的LInux系统中可使用varnishlog.service服务实现；
        日志文件：/var/log/varnish/varnish.log

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

        注意：默认状况下vanish会将全部的Apache combined格式的日志信息记录于共享内存域中，若是想要将此类日志信息保存至文件系统中，CentOS系发行版的LInux系统中可使用varnishncsa.service服务实现；
        日志文件：/var/log/varnish/varnishncsa.log

varnish中的内建函数和关键字：
    Function（函数）：
        regsub(str, regex, sub)
            将str中被regex第一次匹配到的部分换成sub；能够用于rewrite；
        regsuball(str, regex, sub)
            将str中全部可以被regex匹配到的部分都缓存sub；
        ban(boolean expression)
            修剪全部被boolean expression匹配的结果为"TRUE"的缓存对象；
        hash_data(input)
            用于指明对哪些数据进行哈希运算，主要用于经过指定特定键的方式提供命中率和查找效率；
        synthetic(str)
            发送一段信息；
            能够实现purge操做；

    Keyword（关键字）
        1.call subroutines：调用
        2.return(action)
        3.new
        4.set
        5.unset