部署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地址专注于为中小企业提供成都网站设计、网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业仪陇免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了1000+企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。
一、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的缓存服务器，清除缓存测试访问如下：
测试完成！
3.配置http服务器的访问获取客户端的IP地址
如果不配置的情况下，http服务器只会记录Varnish服务器的IP地址，上面Varnish配置文件中已经配置完成。那么httpd的配置如下：
[root@localhost ~]# vim /etc/httpd/conf/httpd.conf //修改http主配置文件
196 LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
197 LogFormat "%h %l %u %t \"%r\" %>s %b" common
//添加以下内容，使http服务可以截取到客户端的IP地址
198 LogFormat "%{X-Forwarded-For}i %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User- Agent}i\"" combined
//X-Forwarded-For参数已经在Varnish配置文件中定义
[root@localhost ~]# systemctl restart httpd //重新启动http服务两台http服务器都需配置（防止时间过长切换到另一台服务器）。
注意：测试时清除缓存！
客户端依然访问Varnish服务器，http访问日志如下：
测试完成！！！
——————————————本文到此为止，感谢观看————————————
本文标题：部署Varnish缓存搭理服务器
URL地址：http://cdiso.cn/article/ghpjgs.html
