varnish 缓存服务器配置与使用

一、cache

1.缓存为什么会存在？

一个快的设备要想和慢的设备交互，只有一种办法就是让快的设备工作在慢的设备的频段上！这样的话就浪费了，我们可以在两者之间加上一个加速器，这个加速器就叫做缓存！

CPU要读取一个数据时，首先从Cache中查找，如果找到就立即读取并送给CPU处理；如果没有找到，就用相对慢的速度从内存中读取并送给CPU处理，同时把这个数据所在的数据块调入Cache中，可以使得以后对整块数据的读取都从Cache中进行，不必再调用内存。cpu的缓存分为三个等级，L1级别频率最接近cpu性能，后次之！

程序的运行具有局部性特征：
    时间局部性
    空间局部性

    cache：命中 

    热区：局部性；
        时效性：
            缓存空间耗尽：LRU（最近最少使用算法清理）
            过期：缓存清理

缓存命中率：命中次数 /(命中次数+miss)

    在此区间(0,1)

    页面命中率：基于页面数量进行衡量
    字节命中率：基于页面的体积进行衡量

缓存与否：

    私有数据：private，private cache；
    公共数据：public, public or private cache;

2.Web的缓存

3.web高速缓存相关的头字段

最重要的缓存头字段有：

• Expires：过期时间；

     Expires:Thu, 22 Oct 2026 06:34:30 GMT
  

• Cache-Control
• Etag
• Last-Modified
• If-Modified-Since
• If-None-Match
• Vary：值
• Age：已缓存时间

4.缓存有效性判断机制：

　　用户访问缓存，缓存的内容是否过期，没过期返回用户缓存的内容。另一种就是即便没过期也要就去请求后端主机如果后端主机的内容没发生改变（基于元数据的时间戳验证或 Etag）返回缓存服务器（304）校验码，然后缓存（若过期就再续期）并发送缓存上的内容到客户，如果后端内容发生改变就发送新的内容到缓存服务器，服务器经过判断是否进行缓存，相应给用户。（条件式请求 ）

过期时间：Expires

    HTTP/1.0
        Expires
    HTTP/1.1
        Cache-Control: maxage=
        Cache-Control: s-maxage=

条件式请求：

    Last-Modified/If-Modified-Since （时间戳验证）
    Etag/If-None-Match （Etag 验证）

　

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

缓存控制

        cache-request-directive =

            "no-cache"                         
            | "no-store" //不要缓存的实体，要求现在从WEB服务器去取                        
            | "max-age" "=" delta-seconds   #最大缓存时长     
            | "max-stale" [ "=" delta-seconds ]  //可以接受过去的对象，但是过期时间必须小于 max-stale 值
            | "min-fresh" "=" delta-seconds    //接受其新鲜生命期大于其当前 Age 跟 min-fresh 值之和的缓存对象   
            | "no-transform"                    
            | "only-if-cached"   //只有当缓存中有副本时,客户端才会获取一份副本               
            | cache-extension                    


        cache-response-directive =

            "public"    //可以用 Cached 内容回应任何用户                           
            | "private" [ "=" <"> 1#field-name <"> ]  //只能用缓存内容回应先前请求该内容的那个用户
            | "no-cache" [ "=" <"> 1#field-name <"> ]
            | "no-store"                            
            | "no-transform"                        
            | "must-revalidate"                     
            | "proxy-revalidate"                  
            | "max-age" "=" delta-seconds           
            | "s-maxage" "=" delta-seconds          
            | cache-extension

缓存相关的HTTP首部

HTTP协议提供了多个首部用以实现页面缓存及缓存失效的相关功能，这其中最常用的有：
(1)Expires：用于指定某web对象的过期日期/时间，通常为GMT格式；一般不应该将此设定的未来过长的时间，一年的长度对大多场景来说足矣；其常用于为纯静态内容如JavaScripts样式表或图片指定缓存周期；
(2)Cache-Control：用于定义所有的缓存机制都必须遵循的缓存指示，这些指示是一些特定的指令，包括public、private、no-cache(表示可以存储，但在重新验正其有效性之前不能用于响应客户端请求)、no-store、max-age、s-maxage以及must-revalidate等；Cache-Control中设定的时间会覆盖Expires中指定的时间；
(3)Etag：响应首部，用于在响应报文中为某web资源定义版本标识符；
(4)Last-Mofified：响应首部，用于回应客户端关于Last-Modified-Since或If-None-Match首部的请求，以通知客户端其请求的web对象最近的修改时间；
(5)If-Modified-Since：条件式请求首部，如果在此首部指定的时间后其请求的web内容发生了更改，则服务器响应更改后的内容，否则，则响应304(not modified)；
(6)If-None-Match：条件式请求首部；web服务器为某web内容定义了Etag首部，客户端请求时能获取并保存这个首部的值(即标签)；而后在后续的请求中会通过If-None-Match首部附加其认可的标签列表并让服务器端检验其原始内容是否有可以与此列表中的某标签匹配的标签；如果有，则响应304，否则，则返回原始内容；
(7)Vary：响应首部，原始服务器根据请求来源的不同响应的可能会有所不同的首部，最常用的是Vary: Accept-Encoding，用于通知缓存机制其内容看起来可能不同于用户请求时Accept-Encoding-header首部标识的编码格式；
(8)Age：缓存服务器可以发送的一个额外的响应首部，用于指定响应的有效期限；浏览器通常根据此首部决定内容的缓存时长；如果响应报文首部还使用了max-age指令，那么缓存的有效时长为“max-age减去Age”的结果；

开源解决方案：
    squid：但是稳定 
    varnish：较新

二、varnsh：简介

Varnish是一款高性能的开源HTTP加速器，挪威最大的在线报纸 Verdens Gang 使用3台Varnish代替了原来的12台Squid，性能比以前更好。

1、varnish官方站点：

 http://www.varnish-cache.org/

        Community：社区版
        Enterprise：企业版

2、架构

varnish主要运行两个进程：Management进程和Child进程（也叫Cache进程）。

Manager进程 主要实现应用新的配置、编译VCL、监控varnish、初始化varnish以及提供一个命令行接口等。Management进程会每隔一段时间探测一下Child进程以判断其是否正常运行，如果在指定的时长内未得到Child进程的回应，Mangagement将会重启此Child进程。

Cacher进程，包含多种类型的线程：

    accept：接受新的连接请求并响应
    worker：child进程会为每个用户启动一个worker进程，因此，在高并发的场景中可能会出现数百个worker进程甚至更多
    expiry：从缓存中清理过期内容

varnish日志 varnishncsa.service

为了与系统的其他部分进行交互，Child进程使用了可以通过文件系统接口进行访问的共享内存日志（shared memory log），因此，如果某线程需要记录信息，其仅需要持有一个锁，而后向共享内存中的某内存区域写入数据，再释放持有的锁即可。而为了减少竞争，每个worker线程都使用了日志数据缓存
共享内存大小一般为90M，其分为两部分，前一部分为计数器，后半部分为客户端请求的数据。varnish通过了多个不同的工具，如varnishlog、varnishncsa或varnishstst等来分析共享内存日志中的信息并能够以指定的方式进行显示

shared memory log：
    统计数据：计数器；
    日志区域：日志记录；
        varnishlog, varnishncsa, varnishstat... 

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

varnish的后端存储

varnish支持多种不同类型的后端存储。这可以在varnish启动时使用-s选项指定。后端存储的类型包括

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

· file[,path[,size[,granularity]]]
    文件存储，黑盒；重启后所有缓存项失效；

· persistent,path,size
    文件存储，黑盒；重启后所有缓存项有效；实验；

varnish无法追踪某缓存对象是否存入了缓存文件，而后也就无法得知磁盘上的缓存文件是否可用，因此，file存储在varnish停止或重启是会清除数据。而persistent方法的出现对此有一个弥补，但persistent仍处于测试阶段

三、varnish的程序环境：

0.安装

1、配置文件

/etc/varnish/varnish.params： 配置varnish服务进程的工作特性，例如监听的地址和端口，缓存机制；程序选项，运行时参数设定！
/etc/varnish/default.vcl：配置各Child/Cache线程的工作属性；

2、主程序：

/usr/sbin/varnishd

监听端口：

面向客户端，nginx后边的那一端监听在 6081，而不是80端口！varnishadm管理控制端口是6082！尽量监听在127.0.0.1 网段的接口，通过秘钥文件使两者相连接

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命令

1、程序选项：/etc/varnish/varnish.params文件

-a address[:port][,address[:port][...]，自己监听的端口，本机所有的地址默认为6081端口； 
-P file Varnish进程PID文件存放路径

-p param=value 指定服务器参数，用来优化varnish性能 

-T address[:port]，设定varnish的telnet管理地址及其端口；默认为6082端口；

-s [name=]type[,options]，定义缓存存储机制；常用的方式有：“-s file,<dir_or_file>,<size>”

-S ：加载的密钥文件
-u user
-g group

-c :仅编译，测试用

-f config：VCL配置文件；指定varnish服务器的配置文件 

-F：运行于前台；
-w int[,int[,int]] 设定varnish的工作线程数，常用的方式有：  
      -w min,max  
      -w min,max,timeout  
      例如：-w5,51200,30，这里需要说明下，在varnish2.0版本以后，最小启动的线程数不能设定过大，设置过大，会导致varnish运行异常缓慢。
...

运行时参数（可以在运行时修改）：/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

测试启动：流程
更改配置文件，配置httpd主机，启动。

修改配置文件仅开放本地主机登录varnish端口

varnish主机（10.1.6.72）

加载配置文件

后端httpd主机（10.1.6.172）

访问

五、varnishadm（手动控制varnish命令）

-S /etc/varnish/secret -T [ADDRESS:]PORT 
 （-S 指明连接时用的密钥 -T 指明地址和端口 6082）

help [<command>]：#获取命令的使用帮助
ping [<timestamp>]：#探测服务是否OK
auth <response>：#认证
quit：#退出
banner：#显示信息
status：#显示当前服务的状态
start：#启动子进程一般用于启动varnishd
stop：#关闭varnishd
vcl.load <configname> <filename>：手动装载配置文件，（要先起个名）
vcl.inline <configname> <quoted_VCLstring>
vcl.use <configname>：#指明使用哪个版本
vcl.discard <configname>：#删除指定版本
vcl.list ：#列出已经编译成功vcl版本，（每写一次就会编译一个版本）

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    

1.vcl配置文件相关：

vcl.list 
vcl.load：装载，加载并编译；
vcl.use：激活；
vcl.discard：删除；
vcl.show [-v] <configname>：查看指定的配置文件的详细信息；

2.运行时参数：

param.show -l：显示列表；
param.show <PARAM>
param.set <PARAM> <VALUE>

3、缓存存储：

storage.list

4、后端服务器：

backend.list 

六 、VCL

　　Varnish Configuration Language，缩写为VCL，即Varnish配置语言，它提供了一种控制Varnish工作的接口，使用该语言配置缓存的处理策略，然后通过管理进程将其解释为C代码，然后使用C编译器编译后，链接至正在运行的Varnish实例。C 语言特点

　　VCL策略在启用前，会由management进程将其转换为C代码，而后再有gcc编译器将C代码编译成二进制程序。编译完成后，management负责将其连接至varnish实例，即Child进程。正式由于编译工作在child进程之外完成，它避免了转载错误格式VCL的风险，因此，varnish修改配置的开销非常小，其可以同时保有几分尚在引用的旧版本配置，也能够让新的配置即刻生效，编译后的旧版本配置通常在varnish重启时才会被丢弃，如果需要手动清理，则可以使用varnishadm的vcl.discard命令来完成

1、老一点版本的流程图

2、新版本的流程图varnish 4.X

亮色的为状态引擎
灰色框的为后端服务器上的操作

VCL函数

3、state engine：状态引擎切换机制

VCL有多个状态引擎，状态之间存在相关性，但彼此间互相隔离；每个状态引擎可使用return(x)指明关联至哪个下一级引擎； vcl_hash –> return(hit) –> vcl_hit

    request: vcl_recv

    response: vcl_deliver

• (1) vcl_hash -(hit)-> vcl_hit –> vcl_deliver
• (2) vcl_hash -(miss)-> vcl_miss –> vcl_backend_fetch –> vcl_backend_response –> vcl_deliver
• (3) vcl_hash -(purge)-> vcl_purge –> vcl_synth
• (4) vcl_hash -(pipe)-> vcl_pipe

两个特殊的引擎：
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 当关键字）; 例如sub vcl_recv { ...}；

(4) No loops, state-limited variables（受限于引擎的内建变量）；

(5) 使用keyword函数和return的返回值来终止当前状态引擎，并交给下一个引擎
(6) Domain-specific;域专用的配置

vcl有限状态机

1.每一个引擎都是被单独处理的
2、每个请求之间都是独立的
3、状态引擎有相关性，但是相互隔离
4、状态引擎之间相互转换用return实现
5、配置文件中写的虽然都是注释的，但是有默认配置！自己的配置会默认放在最前边！

七、vcl语法，及控制编写（.vcl文件的编写）

1、基本语法

        sub subroutine {
            ...
        }

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

        return(), hash_data()

2、VCL Built-in Functions and Keywords

函数：

    regsub(str, regex, sub) #替换函数
    regsuball(str, regex, sub) #全局所有都替换函数
    ban(boolean expression)
    hash_data(input)
    synthetic(str)

VCL提供了几个函数来实现字符串的修改，添加bans，重启VCL状态引擎以及将控制权转回Varnish等。

regsub(str,regex,sub)
regsuball(str,regex,sub)：这两个用于基于正则表达式搜索指定的字符串并将其替换为指定的字符串；但regsuball()可以将str中能够被regex匹配到的字符串统统替换为sub，regsub()只替换一次；
ban(expression)：
ban_url(regex)：Bans所有其URL能够由regex匹配的缓存对象；
purge：从缓存中挑选出某对象以及其相关变种一并删除，这可以通过HTTP协议的PURGE方法完成；
hash_data(str)：
return()：当某VCL域运行结束时将控制权返回给Varnish，并指示Varnish如何进行后续的动作；其可以返回的指令包括：lookup、pass、pipe、hit_for_pass、fetch、deliver和hash等；但某特定域可能仅能返回某些特定的指令，而非前面列出的全部指令；
return(restart)：重新运行整个VCL，即重新从vcl_recv开始进行处理；每一次重启都会增加req.restarts变量中的值，而max_restarts参数则用于限定最大重启次数。

Keywords:关键字

    call subroutine， return(action)，new，set，unset 

操作符：

    ==, !=, ~, >, >=, <, <=
    逻辑操作符：&&, ||, !
    变量赋值：=
    + 两边是字符串的话表示连接

举例：obj.hits

if (obj.hits>0) {
    set resp.http.X-Cache = "HIT via " + server.ip;  #在相应报文中加一个首部为X-Cache = “HiT via ” 再加上服务器ip地址
    } else {
        set resp.http.X-Cache = "MISS via " + server.ip;
    }

应用在deliver中，这样就能在相应报文中看到

2、变量类型：

内建变量：

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.*：存储在缓存空间中的缓存对象的属性；只读；

3、常用变量：

bereq和resp上的是可以控制的

bereq.*, req.*：
    bereq.http.HEADERS*：请求报文的某指定首部
    bereq.request：请求方法；
    bereq.url：请求服务器的url；
    req.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
    server.hostname
client.*
    client.ip    

用户自定义：
    set
    unset     

示例1：强制对某类资源的请求不检查缓存：

vcl_recv {
    if (req.url ~ "(?i)^/(login|admin)") {
        #请求的url做正则匹配（？i）标志位表示不区分正则表达式的大小写，真正匹配的模式在`）`后边
        return(pass);
    }
}

示例2：对于特定类型的资源，例如公开的图片等，取消其私有标识，并强行设定其可以由varnish缓存的时长；

sub vcl_backend_response {
    if (beresp.http.cache-control !~ "s-maxage") {
            #如果请求的首部不是 s-maxage
        if (bereq.url ~ "(?i)\.(jpg|jpeg|png|gif|css|js)$") {
            unset beresp.http.Set-Cookie;
            #表示撤销响应报文
            set beresp.ttl = 3600s;
            #设定缓存时间
                }
            }    
      }

4. 缓存对象的修剪：purge, ban

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

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

这些就是当请求的方法为 ‘PURGE’就发到后端清理缓存。

可以用 curl 命令指定方法请求   -I -X PURGE 来请求

    添加此类请求的访问控制法则：

    一下这个要放在 vcl 4.0；之下，最好在backend之下一行 定义

    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);
        }
        ...
    }

修改配置文件

加载

使用别的网段请求清理

发现清理不掉，这里用本地10.0网段的来清理也是清理不掉

换127网段的来清理，可以清理掉

但是这种清理只针对本地的127网段

因为varnish的缓存是靠url来定义的，一下默认配置段可以看出

所以要想清理远程主机访问的缓存记录，就要先授权一个地址能访问 例授权一个本地主机的地址

这样本地主机就用正常访问的来清理
就好了

这段代码标明：限制那些用户对varnish服务器做purge请求，这里定义了一个函数用来做acl限制。

八、如何设定使用多个后端主机：

1.先定义主机

backend default {
    .host = "172.16.100.6";
    .port = "80";
}

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

2、基于什么方式调用

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

    ...
}
    #这里就表示 如果请求的是.php结尾的文件就用appsrv这个后端主机去相应，。。。。。        

3、基于负载均衡调度 后端多个主机：需要使用模块

varnish module
使用前需要导入：

import director；

示例：

    import 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(); #调用时调用组名
    }

不过这样只能针对不缓存的，也就是说第一次如果请求调度了a主机就直接被缓存下来不会再向后请求了，会以a主机的内容进行相应，不会去访问b主机。但如果针对后端主机进行访问（不缓存的内容），这样才会被轮询调度。

例：

九、varnish对后端主机的健康状态监测

如果检查失败就不会再往那台主机调度。这就是监测机制
默认定义后会自动进行检测

查看后端主机状况 在varnishadm

backend.list

手动指定后端某个主机处于不健康状态（是管理方式的设定，一旦设定就永久为这个状态，不建议）

backend.set_health <定义的主机名>  sick (不健康的) | Healthy （健康的）

BE Health Check：格式

backend BE_NAME { #定义后端主机
    .host =  #后端主机的地址 
    .port =  #后端主机的端口
    .probe = {  #定义检查机制
        .url=   #对url检查
        .timeout=  #超时时间
        .interval=  #每隔多长时间检查一次
        .window=  #基于最近多少次的请求来判定
        .threshhold= #最近.window中定义的这么次检查中至有.threshhold定义的次数是成功的；
    }
}

.probe：定义健康状态检测方法；
    .url：检测时请求的URL，默认为”/"; 
    .request：发出的具体请求；
        .request = 
            "GET /.healthtest.html HTTP/1.1"
            "Host: www.magedu.com"
            "Connection: close"
    .window：基于最近的多少次检查来判断其健康状态； 
    .threshhold：最近.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; #对近5次
    .threshold = 4; #5次中有四次成功
    .interval = 2s; #要加s（秒）;每次检查的频率为2s
    .timeout = 1s; #要加s（秒）；请求时的超时时间1s
}

backend default {
    .host = "10.1.0.68";
    .port = "80";
    .probe = check; #调用检查
}

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

十、varnish的运行参数

1.线程模型：

cache-worker  #处理用户请求
cache-main #
ban lurker #清理缓存项
acceptor：  #接受用户请求
epoll/kqueue： #
...

线程相关的参数：

最大并发连接数=thread_pools * thread_pool_max

在线程池内部，其每一个请求由一个线程来处理； 其worker线程的最大数决定了varnish的并发响应能力；

thread_pools：线程池； 最好小于或等于CPU核心数量； （和nginx 的work进程类似）
thread_pool_max： 每个线程池当中的线程数量（work）每个线程处理一个用户请求
thread_pool_min：每个线程池中最小工作线程数量. 额外意义为“最大空闲线程数”；

thread_pool_timeout：线程空闲阈值。（线程的线程池,至少已经闲置了这么长时间,才会被摧毁。）

thread_pool_add_delay：在需要创建一个线程之前等待时间（因为如果直接创建时间会很慢，在这个时间内可能会有空闲线程被腾出）

thread_pool_destroy_delay：清理线程池的线程所前要等待的时间

设置方式：

    vcl.param 

例：查看某个线程相关的参数

设定参数

永久有效的方法：

编辑/etc/varnish/varnish.params

DEAMON_OPTS="-p PARAM1=VALUE -p PARAM2=VALUE"

十一、varnish日志区域：（默认大小90M）

        shared memory log 
            计数器
            日志信息

1、varnishstat 命令- Varnish 状态信息

    -1 显示有多少种状态字段信息

    -1 -f FILED_NAME #显示你指定的字段的信息

    -l：可用于-f选项指定的字段名称列表；

    不加-1只加-f的话就会动态显示指定字段，-1表示列出意思

我们一般关注

• MAIN.cache_hit ：命中次数
• MAIN.cache_miss ：未命中次数

  ~]# varnishstat -1 -f MAIN.cache_hit -f MAIN.cache_miss
  

2、varnishtop – Varnish 日志中各项的参数记录的排序（首部）

    -1     静态的列出
    -i taglist，可以同时使用多个-i选项，也可以一个选项跟上多个标签；
    -I <[taglist:]regex> #基于正则表达式匹配匹配首部的值；可以有多个（-I .. -I..）
    -x taglist：排除列表（不包含）
    -X  <[taglist]:regex> #基于正则表达式匹配
    -C 持续显示

例:查找在 ReqHeader 首部中包含User-Agent的内容，持续显示

varnishtop -C -I ReqHeader:User-Agent

3、varnishlog 单独记录每次请求的日志信息；按批次记录

*4、 varnishncsa 正常模式下的日志显示，常用

-a  追加日志
-f  自定义格式    

持续记录日志

systemct start  varnishncsa.service 

日志保存位置：

/var/log/varnish/varnishncsa.log


    内建函数：
        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")：purge操作；

总结：

varnish： 状态引擎, vcl

varnish 4.0：

    vcl_init ：定义服务器组
    vcl_recv ：刚收到用户请求时动作可以再此内容定义
    vcl_hash ：哈希用户请求的url等数据来查缓存 
    vcl_hit ：命中后的工作 
    vcl_pass ：不查缓存
    vcl_miss  ：没有命中
    vcl_pipe ：不通过缓存，直接和后端建立管道
    vcl_waiting ：繁忙状态等待
    vcl_purge ：清理缓存
    vcl_deliver ：结果投递
    vcl_synth ：合成相应报文
    vcl_fini ：清理init定义的内容时用到

    vcl_backend_fetch
    vcl_backend_response
    vcl_backend_error 

sub VCL_STATE_ENGINE #定义状态引擎

backend BE_NAME {} #定义后端主机

probe PB_NAME {} #健康状态监测机制

acl ACL_NAME {} #访问控制列表

其他

如果一个varnish不足以给整个网站的规模提供缓存空间，就要再加一台varnish主机，这时就要有调度。
注意： 要考虑缓存命中率问题，可以用url的hash进行调度，要用一致性哈希算法进行调度