Varnish反向代理
varnish代理
varnish是一个高性能的http加速器，是一个反向代理服务器，将数据缓存在内存中，比squid代理的速度快，linux内核版本2.6以上，3台varnish的速度比12台squid的速度还要快
varnish的特点
1、数据缓存在内存中，速度比较快，支持虚拟内存，I/O性能好，能够很好的嵌入到磁盘当中
2、数据不支持持久化，断电或者重启后，数据会丢失（存放不必要的数据）
3、varnish支持精确到秒的缓存
4、支持vcl管理
5、抗DDOS攻击，1个varnish可以抗1个G的DDOS攻击
varnish还能用作负载均衡服务器
调度算法：
round_robin 动态轮询 rr
fallback 选择第一个正常的服务器
random：随机
hash：会话保持
部署varnish反向代理
实验环境
客户机：192.168.1.1
varnish反向代理服务器：192.168.1.4
web服务器：192.168.1.6
实验目的
客户机通过访问varnish代理服务器，获取web终端的页面
实验步骤
第一步：
部署反向代理服务器（192.168.1.4）
# 解决依赖关系
yum -y install automake autoconf libtool pkgconfig graphviz ncurses-devel pcre-devel
# 以下包需要单独拖入
rpm -ivh jemalloc-devel-5.2.0-1.1.x86_64.rpm --nodeps
rpm -ivh libedit-3.0-12.20121213cvs.el7.x86_64.rpm
rpm -ivh libedit-devel-3.0-12.20121213cvs.el7.x86_64.rpm
rpm -ivh python-docutils-0.11-0.3.20130715svn7687.el7.noarch.rpm --nodeps
rpm -ivh python-Sphinx-1.6.5-3.10.1.noarch.rpm --nodeps
# 解压varnish安装包
tar zxf varnish-4.1.11.tgz -C /usr/src
cd /usr/src/varnish-4.1.11/
./configure --prefix=/usr/local/varnish && make && make install
# 命令路径优化
ln -s /usr/local/varnish/sbin/* /usr/local/sbin
ln -s /usr/local/varnish/bin/* /usr/local/bin
# 复制配置文件的模板文件，并改名为default.vcl
cp /usr/local/varnish/share/doc/varnish/example.vcl /usr/local/varnish/default.vcl第二步：
编辑varnish配置文件
vim /usr/local/varnish/default.vcl
修改：
backend default {
.host = "192.168.1.6"; # 后端web服务器
.port = "80"; # web服务的端口号
}启动服务
varnishd -f /usr/local/varnish/default.vcl # 使用配置文件启动
netstat -anpt | grep varnishd # 检测是否启动成功第三步：
部署web服务器（192.168.1.6），因为是实验环境，所以直接使用yum安装
yum -y install httpd
echo "cyj" >> /var/www/html/index.html
systemctl restart httpd
systemctl stop firewalld第四步：
验证
为了更直观的看到是由varnish来获取的页面，所以监听varnish的日志和http的访问日志
varnish反向代理服务器：varnishlog
web服务器：tail -f /var/log/httpd/access_log
客户机：curl 192.168.1.4（varnish反向代理）
部署varnish负载均衡（简单）
在反向代理的基础上部署负载均衡
实验环境
客户端：192.168.1.1
负载均衡（反向代理）：192.168.1.4
web1：192.168.1.6
web2：192.168.1.7
实验目的
客户端通过访问varnish负载均衡服务器，获取到web1和web2的不同页面
实验步骤
首先第二台web按照以上的实验方法进行搭建，生成环境中的web后端的内容是一模一样的，这里为了明显看出效果，内容不一样以作区别
yum -y install httpd
echo "pjf" >> /var/www/html/index.html
systemctl restart httpd
systemctl stop firewalld编辑varnish配置文件，添加对后端的健康检查
vim /usr/local/varnish/default.vcl
添加到后端服务器检查
probe health {
.url = "/"; # 检查请求的url路径
.timeout = 3s; # 超时时间3s
.interval = 1s; # 访问间隔时间1s
.window = 5; # 维持5个窗口
.threshold = 3; # 5个窗口中至少3个是成功的
}
# 满足以上条件的状态为健康
backend web1 {
.host = "192.168.1.6";
.port = "80";
.probe = health; # 添加对本主机的健康检查
}
backend web2 {
.host = "192.168.1.7";
.port = "80";
.probe = health;
}
import directors; # 导入集群模块
sub vcl_init{ # 使用轮询模块
new back = directors.round_robin(); # 使用rr轮询
back.add_backend(web1);
back.add_backend(web2);
}
sub vcl_recv{ # 做了健康检查，必须写这个模块
set req.backend_hint = back.backend(); # 如果站点不健康，则屏蔽掉（rr轮询后端集群）
}
验证
killall -9 varnishd # 多执行几遍
varnishd -C -f /usr/local/varnish/default.vcl # 语法检查
varnishd -f /usr/local/varnish/default.vcl # 启动服务使用客户端验证
curl 192.168.1.4
cyj
curl 192.168.1.4
cyj
curl 192.168.1.4
cyj发现并没有进行rr轮询，这是因为varnish是将数据保存到内存中，使用1.4第一次负载到的web页面一直是web1的页面，需要等一段时间缓存没有之后再次访问就会变为web2的内容了
curl 192.168.1.4
pjf
curl 192.168.1.4
pjf访问出现没有主机路由，则关闭防火墙或者放行端口
varnish单主机实例
配置文件模块
vcl_recv：用来接收处理用户的请求
vcl_hash：如果请求时静态的数据，则去查看varnish本身的缓存
vcl_pass：当请求为动态数据时，则去后端（fetch）获取
vcl_pipe：不符合的请求返回错误页面
vcl_hit：本地找到客户端请求的数据
vcl_miss：本地没有找到客户端请求的数据
vcl_fetch（backend_response）：将数据交给后端的节点
vcl_deliver：将响应交给客户端
预设变量
req：客户端发送给varnish请求使用的变量（req=request）
req.url：客户端请求url
req.http：客户端请求的请求头部
bereq：varnish给后端的服务端的请求使用的变量（bereq：backend request）
bereq.url：varnish请求url
bereq.http：varnish请求头部信息
resp：varnish向客户端响应使用的变量（resp：response）
resp.http：varnish响应客户端的头部信息
resp.status：返回状态码
beresp：服务节点给varnish的响应使用的变量（beresp：backend response）
beresp.uncacheable：响应数据是否不缓存
beresp.ttl：响应数据的缓存时间
obj：缓存在varnish中的数据使用的变量
obj.ttl：varnish本地缓存的时间
obj.hits：varnish本地缓存命中的次数
hash_data()：对客户端请求的内容进行hash计算
hash_data(req.url)
hash_data(req.http.host)
hash_data(server.ip)
varnish是通过vcl语言进行管理的
vcl语言的语法格式：
# 运算符
= 赋值运算符
== 比较运算符
~ 正则匹配
# 逻辑运算符
! 逻辑非
!= 不等于
!~ 不匹配
&& || 逻辑或
# 数据类型
字符串 使用"" 如："abc"
布尔值：
true false
有效时间 s秒 m分 d天
条件判断 if else实验环境
单主机实例也就是后端只有一台web
客户机：192.168.1.1
varnish反向代理：192.168.1.4
web1：192.168.1.6
在varnish反向代理的基础上
实验目的
客户端访问代理服务器，第一次访问后，varnish进行缓存，第二次访问直接访问缓存
实验步骤
调整varnish配置文件
[root@localhost ~]# vim /usr/local/varnish/default.vcl
probe health { # 健康检查
.url = "/"; # 健康检查根目录
.timeout = 5s; # 健康检查超时时间
.interval = 1s; # 间隔时间
.window = 5; # 同时开启5个窗口
.threshold = 3; # 至少保证三个窗口正常，为健康
}
backend web { # 后端服务器，
.host = "192.168.1.6"; # 后端服务器地址
.port = "80"; # 后端服务端口
.probe = health; # 调用健康检查
}
sub vcl_recv{ # 接受数据
set req.backend_hint = web; # 命中后端
if(req.http.X-Forwarded-For){ # 判断客户端对varnish的请求投不中是和否包含X-Forwarded-FOr这个字段
set req.http.X-Forwarded-For=req.http.X-Forwarded-For + "," + client.ip; # 如果在客户端对varnish的请求头部中包含了X-Forwarded-For这个字段，就说明中间经过了那些代理服务器，为了能够看到客户端的真是的IP地址，name将会在请求投不中添加上客户端的IP地址
}
else{
set req.http.X-Forwarded-For=client.ip; # 如果不存在这个字段，将建立这个字段直接是的客户端的IP地址
}
if(req.method != "GET" &&
req.method != "PUT" &&
req.method != "POST" &&
req.method != "DELETE" &&
req.method != "HEAD"
){ # 如果客户端对varnish的请求方式不正常的，那么则进入错误页面
return(pipe);
}
if(req.url ~ "\.(html|htm|png|jpg)$"){ # 如果客户端对varnish的请求路径中是静态数据，则进入到hash模块中
return(hash);
}
if(req.url ~ "\.php$"){ # 如果客户端对varnish的请求路径中过滤出是动态的数据
return(pass); # 则进入到pass 模块中
}
return(hash); # 其他的情况都进入到 hash 模块中
}
sub vcl_hash{ # 静态数据模块
hash_data(req.url); # 将会hash客户端对varnish请求的路径
if(req.http.host){ # 如果请求中有域名
hash_data(req.http.host); #则 hash域名
}
else{
hash_data(server.ip); # 其余情况都 hash IP地址
}
}
sub vcl_pass{ # 动态数据的模块
return(fetch); # 直接进入到后端的模块。
}
sub vcl_pipe{ # 错误数据模块
return(pipe); # 直接结束
}
sub vcl_hit{ # 在varnish中的命中数据的模块
return(deliver); # 直接进入澳结束的模块
}
sub vcl_miss{ # 在varnish中未命中的模块
return(fetch); # 直接进入到后端的模块
}
sub vcl_backend_response{ # 后端数据的模块
if(bereq.url ~ "\.php$"){ # 当varnish对后端的请求中过滤出是动态的数据
set beresp.uncacheable = true; # 则后端对varnish 响应不进行缓存
return(deliver); # 直接进入结束的模块
}
if(bereq.url ~ "\.html$"){ # 当varnish对后端的请求中过滤出是静态的数据
set beresp.ttl = 300s; # 则后端对varnish 的响应缓存时间为 300s
}
return(deliver); # 其余进入结束模块
}
sub vcl_deliver{ # 结束的模块
if(obj.hits > 0){ # 如果缓存中的命中的次数大于 0
set resp.http.X-Cache = "hit~~~"; # 则在varnish对客户端的响应头部中建立一行命中~~~
}
else{
set resp.http.X-Cache = "miss~~~"; # 其余情况则建立一行错过~~~
}
return(deliver); # 正常结束
}检查配置文件语法并启动
varnishd -C -f /usr/local/varnish/default.vcl # 检查语法
killall -9 varnishd # 如果之前启动过，需要先停掉服务
varnishd -f /usr/local/varnish/default.vcl # 启动服务
验证
使用客户端（192.168.1.1）访问，查看http协议头部信息
[root@localhost ~]# curl -I 192.168.1.4
HTTP/1.1 200 OK
Date: Sat, 08 Feb 2020 04:58:02 GMT
Server: Apache/2.4.6 (CentOS)
Last-Modified: Fri, 07 Feb 2020 15:21:52 GMT
ETag: "6-59dfdf301c530"
Content-Length: 6
Content-Type: text/html; charset=UTF-8
X-Varnish: 2
Age: 0
Via: 1.1 varnish-v4
X-Cache: miss~~~ # 第一次访问没有缓存，也就是没有命中，hit<0，返回miss~~~
Accept-Ranges: bytes
Connection: keep-alive
[root@localhost ~]# curl -I 192.168.1.4
HTTP/1.1 200 OK
Date: Sat, 08 Feb 2020 04:58:02 GMT
Server: Apache/2.4.6 (CentOS)
Last-Modified: Fri, 07 Feb 2020 15:21:52 GMT
ETag: "6-59dfdf301c530"
Content-Length: 6
Content-Type: text/html; charset=UTF-8
X-Varnish: 32770 3
Age: 1
Via: 1.1 varnish-v4
X-Cache: hit~~~ # 第二次访问直接访问缓存，也就是命中，hit>0，返回hit~~~
Accept-Ranges: bytes
Connection: keep-alivevarnish多主机实例
实验环境
客户机：192.168.1.1
varnish反向代理：192.168.1.4
web1：192.168.1.6
web2：192.168.1.7
在varnish反向代理的基础上
实验目的
客户机访问
实验步骤
调整varnish配置文件（以下是完整的配置文件）
vim /usr/local/varnish/default.vcl
probe health {
.url = "/"; # 检查请求的url路径
.timeout = 3s; # 超时时间3s
.interval = 1s; # 访问间隔时间1s
.window = 5; # 维持5个窗口
.threshold = 3; # 5个窗口中至少3个是成功的
}
backend web1 { # 后端web集群
.host = "192.168.1.6";
.port = "80";
.probe = health; # 添加对本主机的健康检查
.max_connections = 100;
}
backend web2 { # 后端web集群
.host = "192.168.1.7";
.port = "80";
.probe = health; # 添加对本主机的健康检查
.max_connections = 100;
}
acl allow{ # 对于清除缓存的访问控制列表，只允许本地进行清除缓存
"127.0.0.1";
"localhost";
"192.168.1.4";
}
import directors; # 导入集群模块
sub vcl_init{ # 导入轮询模块
new back = directors.round_robin(); # 轮询方式为rr
back.add_backend(web1); # 轮询web1
back.add_backend(web2); # 轮询web2
}
sub vcl_recv{ # 数据请求模块
set req.backend_hint = back.backend(); # 如果后端站点健康检查为不健康，则屏蔽掉
if(req.method == "PURGE"){ # 如果数据请求的方法为PURGE的情况下
if(client.ip !~ allow){ # 如果客户机ip不在acl允许的访问控制列表中
return(synth(403,"NOT ALLOW")); # 则在主机头中返回状态码403，不允许
}
else{ # 反之（客户机ip在acl中）
return(purge); # 则清除缓存
}
}
if(req.http.host ~ "^img"){ # 如果请求的http协议的host以img开头
set req.backend_hint = web1; # 则调度到web1后端
}
if(req.http.host ~ "^www"){ # 如果请求的http协议的host以www开头
set req.backend_hint = web2; # 则调度到web2后端
}
if(req.url ~ "\.(php|asp|aspx|jsp|do)($|\?)"){ # 如果请求的url为动态数据
return(pass); # 则进入pass模块（去后端索取内容）
}
if(req.url ~ "\.(css|htm|html|png|gif|jpg)($|\?)"){ # 如果请求的url为静态数据
return(hash); # 则进入hash模块进行hash
}
if(req.method != "GET" &&
req.method != "PUT" &&
req.method != "POST" &&
req.method != "DELETE" &&
req.method != "HEAD"
){ # 如果请求的方法非正常
return(pipe); # 则直接到错误页面
}
if(req.method != "GET" && req.method != "HEAD"){ # 如果请求的方法是除了get和head以外的方法
return(pass); # 则进入到pass模块（去后端）
}
if(req.http.Authorization){ # 如果请求头部中存在认证
return(pass); # 则进入到pass模块（去后端）
}
if(req.http.Accept-Encoding){ # 如果浏览器支持编码
if(req.url ~ "\.(png|gif|jpg|jpeg|gz|)"){ # 如果请求的url中包含这些格式的内容
unset req.http.Accept-Encoding; # 则不进行压缩
}
elseif(req.http.Accept-Encoding ~ "gzip"){ # 如果浏览器支持的编码格式为gzip
set req.http.Accept-encoding = "gzip"; # 则使用gzip压缩
}
elseif(req.http.Accept-Encoding ~ "deflate"){ # 如果浏览器支持的编码格式为deflate
set req.http.Accept-Encoding = "deflate"; # 则使用zlib压缩
}
else{ # 否则
unset req.http.Accept-Encoding; # 不进行压缩
}
}
}
# 配置pipe模块
sub vcl_pipe{
return(pipe); # 进入到此模块的，直接退出
}
# 配置pass动态数据模块
sub vcl_pass{
return(fetch); # 进入到此模块的，去后端索取内容
}
# 配置hash静态数据模块
sub vcl_hash{
hash_data(req.url); # 进入到此模块的对url进行hash
if(req.http.host){ # 如果请求的主机头中存在host部分
hash_data(req.http.host); # 则对host进行hash
}
else{ # 如果不存在
hash_data(server.ip); # 则对ip进行hash
if(req.http.Accept-Encoding ~ "gzip"){ # 如果浏览器的编码为gzip
hash_data("gzip"); # 则对gzip文件进行hash
}
elseif(req.http.Accept-Encoding ~ "deflate"){ # 如果浏览器的编码为deflate
hash_data("deflate"); # 则对deflate进行hash
}
}
}
# 配置hit命中模块
sub vcl_hit{
return(deliver); # 进入到hit模块中，则直接返回客户端数据
}
# 配置miss未命中模块
sub vcl_miss{
return(fetch); # 进入到miss模块中，则进入后端获取内容
}
# 配置后端节点模块
sub vcl_backend_response{
if(bereq.url ~ "\.(php|asp|jsp|do)$"){ # 如果返回的url中带有这些后缀的（动态数据）
set beresp.uncacheable = true; # 不在本地进行缓存
}
if(bereq.url ~ "\.(css|js|html|png|gif)"){ # 如果返回的url中带有这些后缀的（静态数据）
set beresp.ttl = 15m; # 将内容在内存中缓存停留15分钟
}
if(bereq.url ~ "\.(gz|bz2|mp3)"){ # 如果返回的url中带有这些后缀的
set beresp.ttl = 30m; # 将内容在内存中缓存停留30分钟
}
return(deliver); # 其余的直接交给客户端
}
# 配置清除缓存的模块
sub vcl_purge{
return(synth(200,"success~~~")); # 进入到purge模块的返回状态码200， 信息success~~~
}
# 配置响应客户端
sub vcl_deliver{
if(obj.hits > 0){ # 如果缓存命中次数大于0
set resp.http.X-Cache = "hit~~~"; # varnish返回给客户端的信息头部，新建一条hit~~~
}
else{ # 反之
set resp.http.X-Cache = "miss~~~"; # varnish返回给客户端的信息头部，新建一条miss~~~
}
return(deliver); # 正常结束
}检查语法并启动服务
varnishd -C -f /usr/local/varnish/default.vcl # 检查语法
killall -9 varnishd # 如果之前启动过，需要先停掉服务
varnishd -f /usr/local/varnish/default.vcl # 启动服务
验证
客户机访问
[root@localhost ~]# curl -I 192.168.1.4
HTTP/1.1 200 OK
Date: Fri, 07 Feb 2020 05:11:43 GMT
Server: Apache/2.4.6 (CentOS)
Last-Modified: Thu, 06 Feb 2020 05:41:13 GMT
ETag: "4-59de1b88eb4c8"
Content-Length: 4
Content-Type: text/html; charset=UTF-8
X-Varnish: 32773
Age: 0
Via: 1.1 varnish-v4
X-Cache: miss~~~ # 第一次访问未命中，需要第一次缓存
Accept-Ranges: bytes
Connection: keep-alive
[root@localhost ~]# curl -I 192.168.1.4
HTTP/1.1 200 OK
Date: Fri, 07 Feb 2020 05:11:43 GMT
Server: Apache/2.4.6 (CentOS)
Last-Modified: Thu, 06 Feb 2020 05:41:13 GMT
ETag: "4-59de1b88eb4c8"
Content-Length: 4
Content-Type: text/html; charset=UTF-8
X-Varnish: 32776 32774
Age: 1
Via: 1.1 varnish-v4
X-Cache: hit~~~ # 第二次命中，因为第一次已经有缓存，所以直接可以获取结果
Accept-Ranges: bytes
Connection: keep-alive
因为有两个web端，我们访问两次试试
[root@localhost ~]# curl 192.168.1.4
cyj
[root@localhost ~]# curl 192.168.1.4
cyj
发现并不能轮询，在配置文件中做了清除缓存的配置，而且配置只有varnish服务器才可以清楚
varnish反向代理服务器
[root@localhost ~]# curl -I http://192.168.1.4 -X PURGE
HTTP/1.1 200 success~~~ # 返回success~~~，清除成功
Date: Fri, 07 Feb 2020 05:18:16 GMT
Server: Varnish
X-Varnish: 32780
Content-Type: text/html; charset=utf-8
Retry-After: 5
Content-Length: 252
Accept-Ranges: bytes
Connection: keep-alive随便一台ping通的服务器
[root@localhost ~]# curl -I http://192.168.1.4 -X PURGE
HTTP/1.1 403 NOT ALLOW # 403权限拒绝
Date: Fri, 07 Feb 2020 05:17:17 GMT
Server: Varnish
X-Varnish: 65540
Content-Type: text/html; charset=utf-8
Retry-After: 5
Content-Length: 249
Connection: keep-alive清除缓存后再次使用客户机访问varnish
[root@localhost ~]# curl 192.168.1.4
pjf
[root@localhost ~]# curl 192.168.1.4
pjfvarnish的启动参数
-a：指定varnish服务的监听端口
例： -a：192.168.1.4：80
-f：指定配置文件
-n：指定varnish的工作目录
-P：指定varnish的pid文件的存放位置
-s：指定varnish缓存数据的文件
-T：指定远程管理varnish的ip和端口
例：-T 192.168.1.1:3500
-S：指定远程主机管理varnish主机使用的密钥文件
-p：指定varnish的运行参数
例：-p thread_pools=2 # 指定varnish开启的线程池的数量，可以与cpu核心数一致
-p thread_pool_min=50 # 单个线程池的最小线程数
-p thread_pool_max=5000 # 单个线程池的最大线程数
-p thread_pool_timeout=30 # 每个线程的超时时间(单位s)
lru_interval=30 # 默认缓存时间
远程管理varnish主机
远程管理需要用到密钥
所以需要在varnish服务器生成密钥
dd if=/dev/random of=/etc/vc count=1
cat /etc/vc
𘛂ג6°¦ה`¹@LKfgҘ¾H5找`£³}¹3¥:6d鞥؊Z!§²Δ45<Ղ٨0HƐӯ¸{ګd¨eJbbþ
!ϧDI#±J重启服务
killall -9 varnishh # 停掉服务
varnishd -a 192.168.1.4:80 -f /usr/local/varnish/default.vcl -n /usr/local/varnish -P /usr/local/varnish/varnish.pid -s file,/usr/local/varnish/cache.data,1G -T 192.168.1.4:3500 -S /etc/vc -p thread_pools=2 -p thread_pool_min=50 -p thread_pool_max=1000 -p thread_pool_timeout=30 -p lru_interval=20
# 开放3500管理端口用作远程管理在生产环境中的另一台varnish来管理这台varnish，/etc/vc需要scp传过去
varnishadm -T 192.168.1.4:3500 -S /etc/vc # 进行远程登陆
200
-----------------------------
Varnish Cache CLI 1.0
-----------------------------
Linux,3.10.0-862.el7.x86_64,x86_64,-jnone,-sfile,-smalloc,-hcritbit
varnish-4.1.11 revision 61367ed17d08a9ef80a2d42dc84caef79cdeee7a
Type 'help' for command list.
Type 'quit' to close CLI session.
varnish> ping # 验证管理端被管理端的联通性
200
PONG 1581055386 1.0
varnish> status # 查看被管理端服务的状态
200
Child in state running
varnish> backend.list # 查看被管理端中负载的服务器
200
Backend name Admin Probe
boot.web1 probe Healthy 5/5
boot.web2 probe Healthy 5/5查看当前varnish的状态varnishstat
[root@localhost ~]# cd /usr/local/varnish/
[root@localhost varnish]# cp _.vsm /usr/local/varnish/var/varnish/localhost/_.vsm
cp：是否覆盖"/usr/local/varnish/var/varnish/localhost/_.vsm"？ y
[root@localhost ~]# varnishstat查看当前varinish的日志varnishlog
[root@localhost ~]# varnish -n /usr/local/varnish/ -w /usr/local/varnish/varnish.log
# 会变成阻塞状态需要使用客户端访问一下，因为只有客户端正常访问，才能生成日志
[root@localhost ~]# curl 192.168.1.4
cyj然后打开另一台终端，查看路径下的日志
[root@localhost varnish]# ls
bin default.vcl lib share varnish.log vcl_boot.1581054725.643835306
cache.data include sbin var varnish.pid _.vsm此时的日志，使用cat是看不懂的
所以将varnishlog打断，使用另一个命令生成日志varnishncsa，用法与varnishlog一致
# 执行命令之前要将之前生成的log文件删除
varnishncsa -n /usr/local/varnish/ -w /usr/local/varnish/varnish.log
# 还是阻塞状态需要使用客户端访问一下，因为只有客户端正常访问，才能生成日志
[root@localhost ~]# curl 192.168.1.4
pjf然后打开另一台终端，查看路径下的日志
[root@localhost varnish]# ls
bin default.vcl lib share varnish.log vcl_boot.1581054725.643835306
cache.data include sbin var varnish.pid _.vsm此时的日志，使用cat就可以看懂了
cat /usr/local/varnish/varnish.log
192.168.1.1 - - [07/Feb/2020:14:22:47 +0800] "GET http://192.168.1.4/ HTTP/1.1" 200 4 "-" "curl/7.29.00"博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议
本文永久链接是：https://www.feiyiblog.com/2020/02/09/Varnish%E5%8F%8D%E5%90%91%E4%BB%A3%E7%90%86/
