筱振

部署Varnish缓存搭理服务器

博文大纲：
一、Varnish概述
1.Varnish简介
2.Varnish和squid的区别
3.Varnish的工作原理
4.Varnish架构
5.Varnish配置
6.VCL中内置预设变量
7.VCL的子程序
8.特定功能语句
9.return语句
10.Varnish请求处理的步骤
11.Varnish的优雅模式
二、安装Varnish
1.客户端访问测试缓存
2.服务端测试清除缓存
3.配置http服务器的访问获取客户端的IP地址

一、Varnish概述

1.Varnish简介

Varnish是一款高性能且开源的反向代理服务器和HTTP加速器，其采用全新的软件体系机构，和现在的硬件体系紧密配合。与传统的squid相比，Varnish具有高性能、速度快、管理更加方便等优点，目前很多大型的网站都开始尝试使用Varnish来代替squid，这便是Varnish迅速发展的最根本的原因。

Varnish的主要特征：

（1）缓存代理位置：可以使用内存也可以使用磁盘；
（2）日志存储：日志存储在内存中；
（3）支持虚拟内存的使用；
（4）有精确的时间管理机制，即缓存的时间属性控制；
（5）状态引擎架构：在不同的引擎上完成对不同的缓存和代理数据进行处理；
（6）缓存管理：以二叉堆管理缓存数据，做到数据的及时清理；

2.Varnish和squid的区别

相同点：

都是一个反向代理服务器；
都是开源软件；

Varnish的优势：

（1）稳定性：Varnish和Squid在完成相同负载的工作时，Squid服务器发生故障的几率要高于Varnish，因为使用Squid需要经常重启；
（2）访问速度更快：Varnish所有缓存的数据都是直接从内存中读取，而Squid是从硬盘中读取；
（3）支持更多的并发连接：因为Varnish的TCP连接和释放的速度比Squid快很多

Varnish的缺陷：

（1）Varnish进程一旦重启，缓存数据都会从内存中完全释放，此时所有请求都会发送到后端服务器，在高并发情况下，会给后端服务器造成很大压力；
（2）在Varnish使用中如果使用单个URL的请求通过负载均衡时，则每次请求都会落在不同的Varnish服务器中，造成请求都会到后端服务器；而且同样的秦桂在多台服务器上缓存，也会造成Varnish的缓存资源的浪费，造成性能下降；

Varnish缺陷的解决方案：

针对缺陷（1）：在访问量很大的情况下推荐使用Varnish的内存缓存方式启动，而且后面需要跟多台Nginx服务器（作为反向代理）。主要防止Varnish服务器重启的情况下，大量的请求到达后端服务器；这样Nginx就是第二道缓存代理服务器。防止请求过多时给后端服务器造成较大的压力；
针对缺陷（2）：可以在负载均衡上做URL哈希，让单个URL请求固定到一台Varnish服务器上；

3.Varnish的工作原理

当Varnish服务器收到客户端的请求时，首选检查缓存中是否有数据，如果有，则直接响应客户端；如果没有则向后端服务器请求相应的资源，缓存到Varnish服务器本地，再响应客户端；

根据规则和请求页面的类型选择数据是否需要进行缓存，可以根据请求头中Cache-Contorl判断是否缓存，以及cookis是否有标记，这些功能都可以通过编写配置文件的方式来实现。

4.Varnish架构

Varnish分为management进程和child进程：

management进程：对child进程进行管理，同事对VCL配置进行编译，并应用到不同的状态引擎中；
child进程：生成线程池，负责对用户请求进行处理，并通过hash查找返回用户结果；

child进程生成的常见线程有：

accept线程：接收新的连接请求并响应；

worker线程：会话，处理请求资源；

expiry线程：清除缓存中过期的内容；

5.Varnish配置

Varnish主要配置部分：

后端配置：给Varnish添加反向代理服务器节点，最少配置一个；

ACL配置：给Varnish添加访问控制列表，可以指定这些列表访问或禁止访问；

probes配置：给Varnish添加探测后端服务器是否正常的规则，方便切换或禁止对应后端服务器；

directors配置：给Varnish添加负载均衡模式管理多个后端服务器；

核心子程序配置：给Varnish添加后端服务器切换，请求缓存、访问控制、错误处理等规则；

6.VCL中内置预设变量

如图：

req：客户端请求Varnish服务器时可用的变量；
bereq：Varnish服务器请求后端服务器可用的变量；
beresp：后端服务器响应Varnish服务器请求，并返回结果时，使用的变量；
resp：Varnish服务器响应客户端请求是使用的变量；
obj：高速缓存对象，缓存后端响应请求内容；
now：作用就是返回当前的时间戳；

7.VCL的子程序

客户端基本信息：

Client ip：返回客户端的IP地址；
Client port：获取客户端请求的端口号（需调用std）；
Client.identiy：获取客户端标识码；

服务端基本信息：

Server.hostname：服务器主机名；
Server.identiy：获取服务器标识码；
Server.ip：获取服务器IP地址；
Server.prot：获取服务器IP端口号（需调用std模块）；

客户端请求（req）：

Req：整个请求的数据结构；
req.bachend_hint：指定请求后端节点如gif 给图片服务器（hint暗示）当访问时gif时设置客户端的请求req.bachend_hint=图片服务器地址；
Req.can_gzip：客户端是否接受gzip传输编码；
req.hash_always_miss：是否从缓存中读取数据；
req.hash_ignore_busy：忽略缓存中忙碌的数据；
req.http：对应请求http的header；
req.method ：请求类型或者请求的方式；
req.proto：客户端请求使用的http协议的版本；
req.restarts：重新启动次数，默认最大值是4（通常用于判断是否访问过服务器）；
req.url：请求的url；
req.xid：请求的唯一ID号；

varnish请求后端服务器（bereq）：

bereq：整个后端请求的数据结构；
bereq.backend：所请求后端节点的配置；
bereq.between_bytes_timeout：从后端每接收一个字节之间的等待时间或者超时时间；
bereq.http：对应发送到后端的http的头部信息；
bereq.method：发送到后端的请求类型或者请求方式；
bereq.proto：发送到后端的请求的http协议版本；
bereq.retires：相同请求重试计数；
bereq.uncacheable：请求数据没有被缓存，或者请求不缓存；
bereq.url：发送到后端请求的url；
bereq.xid：请求唯一id；

后端服务器向varnish（beresq）：

Beresp：后端服务器响应数据；
Beresp.backend.ip：后端响应（处理请求数据）服务器的IP地址；
Beresp.backend.name：后端响应服务器的节点名；
Beresp.do_gunzip：默认为false，缓存前解压改对象；
Beresp.grace：设置缓存过期的额外宽限时间；
Beresp.http：响应时http的头部；
Beresp.keep：对象缓存后带保持时间；
Beresp.proto：响应的http版本；
Beresp.reason ：后端服务器返回的http状态信息；
Beresp.status：后端服务器返回的在状态码；
Beresp.storage_hint：指定保存的的特定存储器（内存）；
Beresp.ttl：改对象缓存的剩余时间，指定统一缓存剩余时间；
Beresp,uncacheable：对数据不进行缓存；

高速缓存对象（obj）：

obj.grace：该对象额外宽限时间；
obj.hits：缓存命中次数，一般可以用于判断是否有缓存；
obj.http：对应 HTTP 的 header；
obj.proto：HTTP版本；
obj.reason：服务器返回的 HTTP 状态；
obj.status：服务器返回的状态码；
obj.ttl：该对象缓存剩余时间（秒）；
obj.uncacheable：不缓存；

返回给客户端的响应对象（resp）：

resp：整个响应数据结构；
resp.http：对应 HTTP 的 header；
resp.proto：编辑响应的 HTTP 协议版本；
resp.reason：将要返回的 HTTP 状态信息；
resq.status：将要返回的 HTTP 状态；

8.特定功能语句

Ban（expression）：清除指定对象缓存；
Call(subroutine)：调用子程序；
Hash_data（input）：根据input的子程序的值生成hash键；
New（）：创建新的vcl对象，只能在vcl_init 子进程中；
Return（）：结束当前子程序，并指定继续下一步动作；
Rollback()：恢复 HTTP 头到原来状态，已经弃用，使用 std.rollback() 代替；
Synthetic （STRING）：合成器，定义返回给客户端页面和状态码；
Regsub（str，regex，sub）使用正则表达式替换第一次出现的字符串；
Regsuball（str，regex,sub）替换所有出现的字符串；

9.return语句

return 语句是终止子程序并返回动作，所有动作都根据不同的 vcl 子程序限定来选用的。

语法：return （action）；

常用的选项：

abandon：放弃处理，并生成一个错误；

deliver：交付处理；

fetch：从后端取出响应对象；

hash：哈希缓存处理；

lookup：查找缓存；

ok：继续执行；

pass：进入 pass 非缓存模式；

pipe：进入 pipe 非缓存模式；

purge：清除缓存对象，构建响应；

restart：重新开始retry 重试后端处理；

synth(status code,reason)：合成返回客户端状态；

10.Varnish请求处理的步骤

如图：

VCL处理过程大致分为如下几个步骤:
(1)Receive 状态,也就是请求处理的入口状态,根据 VCL 规则判断该请求应该是 Pass 或Pipe,或者进入 Lookup(本地查询)；
(2)Lookup 状态,进入此状态后,会在 hash 表中查找数据,若找到,则进入 Hit 状态,否则进入 miss 状态；
(3)Pass 状态,在此状态下,会进入后端请求,即进入 fetch 状态；
(4)Fetch 状态,在 Fetch 状态下,对请求进行后端的获取,发送请求,获得数据,并进行本地存储；
(5)Deliver 状态, 将获取到的数据发送给客户端,然后完成本次请求；

11.Varnish的优雅模式

当几个客户端请求同一个页面的时候，varnish 只发送一个请求到后端服务器，然后让其他几个请求挂起并等待返回结果；获得结果后，其它请求再复制后端的结果发送给客户端；但如果同时有数以千计的请求，那么这个等待队列将变得庞大，这将导致 2 类潜在问题：惊群问题(thundering herd problem)，即突然释放大量的线程去复制后端返回的结果，将导致负载急速上升；没有用户喜欢等待；

故为了解决这类问题，可以配置 varnish 在缓存对象因超时失效后再保留一段时间，以给那些等待的请求返回过去的文件内容(stale content)，配置案例如下：

sub vcl_recv {
 if (! req.backend.healthy) {   #判断后端服务器的健康状态
 set req.grace = 5m;    #如果后端服务器不健康，客户端额外缓存15分钟
}else {
 set req.grace = 15s; }  #正常额外缓存时间15秒
}
sub vcl_fetch { 
set beresp.grace = 30m;  #定义缓存过期后额外缓存时间30分钟
}

二、安装Varnish

获取Varnish软件包

[root@localhost ~]# yum -y install autoconf automake libedit-devel libtool ncurses-devel pcre-devel  pkgconfig python-docutils python-sphinx
//安装Varnish所需依赖
[root@localhost ~]# tar zxf varnish-4.0.3.tar.gz  -C /usr/src
[root@localhost ~]# cd /usr/src/varnish-4.0.3/
[root@localhost varnish-4.0.3]# ./configure && make && make install              //编译安装Varnish
[root@localhost ~]# cp /usr/src/varnish-4.0.3/etc/example.vcl /usr/local/var/varnish/
//复制Varnish主配置文件
[root@localhost ~]# vim /usr/local/var/varnish/example.vcl             //编译Varnish主配置文件
#
# This is an example VCL file for Varnish.
#
# It does not do anything by default, delegating control to the
# builtin VCL. The builtin VCL is called when there is no explicit
# return statement.
#
# See the VCL chapters in the Users Guide at https://www.varnish-cache.org/docs/
# and http://varnish-cache.org/trac/wiki/VCLExamples for more examples.

# Marker to tell the VCL compiler that this VCL has been adapted to the
# new 4.0 format.
vcl 4.0;
import directors;
import std;
# Default backend definition. Set this to point to your content server.
probe backend_healthcheck {
        .url="/"; #访问后端服务器根路径
        .interval = 5s;   #请求时间间隔
        .timeout = 1s;   #请求超时时间
        .window = 5;    #指定轮询次数5次
        .threshold = 3;   #如果出现3次失败则表示后端服务器异常
}
backend web1 {    #定义后端服务器
        .host = "192.168.1.7";  #要转向主机（即后端主机）的 IP 或域名
        .port = "80";  #指定后端服务器的端口号
        .probe = backend_healthcheck;  #健康检查调用backend_healthcheck定义的内容
}
backend web2 {
        .host = "192.168.1.8";
        .port = "80";
        .probe = backend_healthcheck;
}
acl purgers { #定义访问控制列表
        "127.0.0.1";
        "localhost";
        "192.168.1.0/24";
        !"192.168.1.8";
}
sub vcl_init  {     #调用 vcl_init 初始化子程序创建后端主机组，即 directors
        new  web_cluster=directors.round_robin(); #使用 new 关键字创建 drector 对象,使用 round_robin(轮询) 算法
        web_cluster.add_backend(web1);   #添加后端服务器节点
        web_cluster.add_backend(web2);
}
sub vcl_recv {
        set req.backend_hint = web_cluster.backend(); #指定请求的后端节点web_cluster定义的后端节点
        if (req.method == "PURGE") {   #判断客户端的请求头部是否是PURGE
                if (!client.ip ~ purgers) {   #如果是，再判断客户端的IP地址是不是在ACL访问控制列表中.
                        return (synth(405, "Not Allowed."));  #如果不是，返回给客户端405状态码并且返回定义的页面.
        }
        return (purge);   #如果是ACL定义的，则交给purge处理.
}
if (req.method != "GET" &&
        req.method != "HEAD" &&
        req.method != "PUT" &&
        req.method != "POST" &&
        req.method != "TRACE" &&
        req.method != "OPTIONS" &&
        req.method != "PATCH" &&
        req.method != "DELETE") {      #判断客户端的请求类型
                return (pipe);
        }
if (req.method != "GET" && req.method != "HEAD") {
        return (pass);      #如果不是GET及HEAD则交给pass.
}
if (req.url ~ "\.(php|asp|aspx|jsp|do|ashx|shtml)($|\?)") {
        return (pass);   #当客户端访问的是.php等结尾的交给pass处理.
}
if (req.http.Accept-Encoding) {
        if  (req.url  ~ "\.(bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)$") {
        unset req.http.Accept-Encoding;   #取消客户端接收的压缩类型
        } elseif (req.http.Accept-Encoding ~ "gzip") {
                set req.http.Accept-Encoding = "gzip";  #如果有gzip类型，标记gzip类型.
        } elseif (req.http.Accept-Encoding ~ "deflate") {
                set req.http.Accept-Encoding = "deflate";
        } else {
        unset req.http.Accept-Encoding;  #其他未定义的页面也取消客户但接收的压缩类型.
        }
     }
if  (req.url  ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico|gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
        unset req.http.cookie;  #取消客户端的cookie值.
        return (hash);    #将请求转发给hash子程序，也就是查看本地缓存.
}
if (req.restarts == 0) {  #判断客户端是不是第一次请求
        if (req.http.X-Forwarded-For) {     #如果是第一次请求，设置获取客户端的IP地址.
                set req.http.X-Forwarded-For = req.http.X-Forwarded-For + ", " + client.ip;
        } else {
       set req.http.X-Forwarded-For = client.ip;
        }
}
return (hash);
}
sub vcl_hash {
        hash_data(req.url);   #查看客户端请求的页面，并且进行hash
        if (req.http.host) {
                hash_data(req.http.host);  #设置客户端的主机
        } else {
                hash_data(server.ip);    #设置服务器的IP
        }
        return (lookup);
}
sub vcl_hit {
        if (req.method == "PURGE") {   #如果是HIT并且当客户端请求的类型是PURGE返回的200的状态码，并返回相应页面.
                return (synth(200, "Purged."));
        }
        return (deliver);
}
sub vcl_miss {
    if (req.method == "PURGE") {
                return (synth(404, "Purged."));   #如果是miss返回404
        }
        return (fetch);
}
sub vcl_deliver {
        if (obj.hits > 0) {
                set resp.http.CXK = "HIT-from-varnish"; #设置http头部X-Cache =hit
                set resp.http.X-Cache-Hits = obj.hits;  #返回命令的次数
        } else {
        set resp.http.X-Cache = "MISS";
        }
        unset resp.http.X-Powered-By;  #取消显示web版本
        unset resp.http.Server;    #取消显示varnish服务
        unset resp.http.X-Drupal-Cache;   #取消显示缓存的框架
        unset resp.http.Via;    #取消显示文件内容来源
        unset resp.http.Link;  #取消显示HTML的超链接地址
        unset resp.http.X-Varnish;  #取消显示varnish的id
        set resp.http.xx_restarts_count = req.restarts;   #设置客户端请求的次数
        set resp.http.xx_Age = resp.http.Age;   #显示缓存文件的时长
        #set resp.http.hit_count = obj.hits;   #显示缓存命中的次数
        #unset resp.http.Age;
        return (deliver);
}
sub vcl_pass {
        return (fetch);   #将后端服务器返回的数据缓存到本地
}
sub vcl_backend_response {
        set beresp.grace = 5m;   #缓存额外宽限时间
        if (beresp.status == 499 || beresp.status == 404 || beresp.status == 502) {
                set beresp.uncacheable = true;   #当后端服务器相应状态码是449等，不缓存
        }
        if (bereq.url ~ "\.(php|jsp)(\?|$)") {
                set beresp.uncacheable = true;  #当是PHP的页面不缓存
        } else {
                if (bereq.url ~ "\.(css|js|html|htm|bmp|png|gif|jpg|jpeg|ico)($|\?)") {
                set beresp.ttl = 15m;  #当是上面结尾的，缓存15分钟
                unset beresp.http.Set-Cookie;
                } elseif (bereq.url ~ "\.(gz|tgz|bz2|tbz|zip|rar|mp3|mp4|ogg|swf|flv)($|\?)") {
                        set beresp.ttl = 30m; #缓存30分钟
                        unset beresp.http.Set-Cookie;
                } else {
                        set beresp.ttl = 10m;  #生存时间10分钟
                        unset beresp.http.Set-Cookie;
                }
        }
        return (deliver);
}
sub vcl_purge {
        return (synth(200,"success"));
}
sub vcl_backend_error {
        if (beresp.status == 500 ||
                beresp.status == 501 ||
                beresp.status == 502 ||
                beresp.status == 503 ||
                beresp.status == 504) {
                return (retry);  #如果状态码是上述其中之一，则重新请求
        }
}
sub vcl_fini {
        return (ok);
}
[root@localhost ~]# varnishd -f /usr/local/var/varnish/example.vcl -s malloc,200M -a 0.0.0.0:80
//启动varnish服务
//-f指定配置文件存放位置；-s指定启动时使用的内存大小；-a指定监听的地址与端口
[root@localhost ~]# netstat -anpt | grep 80
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      10508/varnishd  
//确定80端口已经在监听

自行搭建两台http服务器（访问页面建议不要一样）！

1.客户端访问测试缓存

首次访问：

按F5刷新后的结果：

2.服务端测试清除缓存

注意：测试时清除缓存！

web服务器（192.168.1.7）

[root@localhost ~]# curl -X "PURGE" 192.168.1.6
//指定192.168.1.6的缓存服务器，清除缓存

测试访问如下：

web服务器（192.168.1.8）

[root@localhost ~]# curl -X "PURGE" 192.168.1.6
//指定192.168.1.6的缓存服务器，清除缓存