基于Centos7怎么部署Varnish緩存代理服務器

這篇文章主要講解了“基于Centos7怎么部署Varnish緩存代理服務器”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“基于Centos7怎么部署Varnish緩存代理服務器”吧！

一.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 劣勢的解決方案

針對劣勢一：在訪問量很大的情況下推薦使用 varnish 的內存緩存方式啟動，而且后面需要 跟多臺 squid/nginx 服務器。主要為了防止前面的 varnish 服 務、服務器被重啟的情況下， 大量請求穿透 varnish，這樣 squid/nginx 可以就擔當第二層 cache，而且也彌補了 varnish 緩 存在內存中重啟都會釋放的問題；
針對劣勢二：可以在負載均衡上做 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添加反向代理服務器節點，最少配置一個；

• acl配置：給varnish添加訪問控制列表，可以指定這些列表訪問或禁止訪問；

• probes配置：給varnish添加探測后端服務器是否正常的規則，方便切換或禁止對應后端服務器；

• directors配置：給varnish添加負載均衡模式管理多個后端服務器；

• 核心子程序配置：給varnish添加后端服務器切換，請求緩存、訪問控制、錯誤處理等規則；

6.vcl 中內置預設變量：變量(也叫 object)：

如圖

（1）req：客戶端請求varnish服務器時可用的變量；
（2）bereq：varnish服務器請求后端服務器可用的變量；
（3）beresp：后端服務器響應varnish服務器請求，并返回結果時，使用的變量；
（4）resp：varnish服務器響應客戶端請求是使用的變量；
（5）obj：高速緩存對象，緩存后端響應請求內容；
（6）now：作用就是返回當前的時間戳；

客戶端

clienet.ip：返回客戶端的ip地址
client.port：獲取客戶端請求的端口號（在vatnish4.0以后需要調取std模塊才能使用）語法為 import std； std.port(client.ip)
client.identiy 獲取客戶端標識碼，軟件在安裝過程中會生成一個序列號，用來標識身份

服務器

server.hostname：服務器主機名
server.identiy：獲取服務器標識碼
server.ip：獲取服務器ip地址
server.prot：獲取服務器ip端口號，需要調用std模塊

客戶端請求req （客戶端請求發送的對象）

• req：整個請求的數據結構

• req.bachend_hint：指定請求后端節點 如gif 給圖片服務器

• req.can_gzip：客戶端是否接受gzip傳輸編碼（通常瀏覽器支持所有壓縮格式）

• req.hash_always_miss：是否從緩存中讀取數據

• req.hash_ignore_busy： 忽略緩存中忙碌的數據 死鎖（如兩臺varnish服務器在處理過程中共同爭搶一個資源造成堵塞，如果不手動停止則會僵持支持僵持下去）

• req.http：對應請求http的header

• req.method ：請求類型或者請求的方式（如gt，post）

• req.proto：客戶端請求使用的http協議的版本

• req.restarts：重新啟動次數，默認最大值是4（通常用于判斷是否訪問過服務器）

• req.url：請求的url

• req.xid：唯一id，varnish服務器訪問時在頭部增加了x-varnish，后面的數字是varnish的id，第一個數據是請求的標識id，第二個數據是緩存的標識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：對數據不進行緩存

存儲

• storage.<name>.free_space：存儲可用空間（字節數）

• storage.<name>.used_space：存儲剩余時間（字節數）

• storage.<name>.happy：存儲節點狀態

• deliver將數據發送給客戶端，返回的數據

• fetch從后端獲取數據，并將數據緩存到本地

7.特定功能語句

• 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）替換所有出現的字符串；

8.varnish請求處理的步驟

如圖

varnish請求處理的步驟

receive 狀態（vcl_recv）。也就是請求處理的入口狀態，根據 vcl 規則判斷該請求應該 pass（vcl_pass）或是 pipe（vcl_pipe），還是進入 lookup（本地查詢）。
lookup 狀態。進入該狀態后，會在 hash 表中查找數據，若找到，則進入 hit（vcl_hit）狀態，否則進入 miss（vcl_miss）狀態。
pass（vcl_pass）狀態。在此狀態下，會直接進入后端請求，即進入 fetch（vcl_fetch）狀態
fetch（vcl_fetch）狀態。在 fetch 狀態下，對請求進行后端獲取，發送請求，獲得數據，并根據設置進行本地存儲。
deliver（vcl_deliver）狀態。將獲取到的數據發給客戶端，然后完成本次請求。
pipe狀態。建立客戶端和服務器之間的直接連接，從后端服務器調取數據

vcl_recv 子程序： 開始處理請求，通過 return (動作);
vcl_pipe 子程序： pipe 模式處理，該模式主要用于直接取后端響應內容返回客戶端，可定義響應內容返回客戶端。
vcl_pass 子程序： pass 模式處理，該模式類似 hash 緩存模式，僅不做緩存處理.
vcl_hit 子程序： hash 緩存模式時，存在 hash 緩存時調用，用于緩存處理，可放棄或修改緩存.
vcl_miss 子程序： hash 緩存模式時，不存在 hash 緩存時調用，用于判斷性的選擇進入后端取響應內容，可以 修改為 pass 模式。
vcl_hash 子程序： hash緩存模式，生成hash值作為緩存查找鍵名提取緩存內容，主要用于緩存hash鍵值處理， 可使用 hash_data(string) 指定鍵值組成結構，可在同一個頁面通過 ip 或 cookie 生成不同的 緩存鍵值。
vcl_purge 子程序： 清理模式，當查找到對應的緩存時清除并調用，用于請求方法清除緩存，并報告
vcl_deliver 子程序： 客戶端交付子程序，在 vcl_backend_response 子程序后調用（非 pipe 模式），或 vcl_hit 子程 序后調用，可用于追加響應頭信息，cookie 等內容。
vcl_backend_fetch 子程序： 發送后端請求之前調用，可用于改變請求地址或其它信息，或放棄請求。
vcl_backend_response 子程序： 后端響應后調用，可用于修改緩存時間及緩存相關信息。
vcl_backend_error 子程序： 后端處理失敗調用，異常頁面展示效果處理，可自定義錯誤響應內容，或修改 beresp.status 與 beresp.http.location 重定向等。
vcl_synth 子程序： 自定義響應內容。可以通過 synthetic（）和返回值 synth 調用，這里可以自定義異常顯示 內容，也可以修改 resp.status 與 resp.http.location 重定向。
vcl_init 子程序： 加載 vcl 時最先調用，用于初始化 vmods，該子程序不參與請求處理，僅在 vcl 加載時調用 一次。
vcl_fini 子程序： 卸載當前 vcl 配置時調用，用于清理 vmods，該子程序不參與請求處理，僅在 vcl 正常丟棄 后調用。

 二.安裝varnish

下載varnish軟件包 鏈接: https://pan.baidu.com/s/1ofnyr-5xfuxmuyjtnhqesa 提取碼: m9q4

除了一臺varnish服務器，可以再開倆臺web服務器，提供web頁面就可以。

[root@localhost ~]# yum -y install autoconf automake libedit-devel libtool ncurses-devel pcre-devel pkgconfig python-docutils python-sphinx
[root@localhost ~]# tar zxf varnish-4.0.3.tar.gz 
[root@localhost ~]# cd varnish-4.0.3/
[root@localhost varnish-4.0.3]# ./configure && make && make install
[root@localhost varnish-4.0.3]# cp etc/example.vcl /usr/local/var/varnish/
//復制varnish主配置文件
[root@localhost /]# vim /usr/local/var/varnish/example.vcl 
//編輯varnish主配 看原來的修改
vcl 4.0;
import directors;
import std;
backend default {
  .host = "127.0.0.1";
  .port = "80";
}
probe backend_healthcheck {
    .url="/";
    .interval = 5s;
    .timeout = 1s;
    .window = 5;
    .threshold = 3;
}
backend web1 {
    .host = "192.168.148.132";
    .port = "80";
    .probe = backend_healthcheck;
}
backend web2 {
    .host = "192.168.148.133";
    .port = "80";
    .probe = backend_healthcheck;
}
acl purgers {
    "127.0.0.1";
    "localhost";
    "192.168.148.0/24";
    !"192.168.148.133";
}
sub vcl_init {
    new web_cluster=directors.round_robin();
    web_cluster.add_backend(web1);
    web_cluster.add_backend(web2);
}
//把原來的全部刪除添加如下
sub vcl_recv {
    set req.backend_hint = web_cluster.backend();
    if (req.method == "purge") {
        if (!client.ip ~ purgers) {
            return (synth(405, "not allowed."));
    }
    return (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);
}
if (req.url ~ "\.(php|asp|aspx|jsp|do|ashx|shtml)($|\?)") {
    return (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";
    } 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;
    return (hash);
}
if (req.restarts == 0) {
    if (req.http.x-forwarded-for) {
        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);
    if (req.http.host) {
    hash_data(req.http.host);
    } else {
        hash_data(server.ip);
    }
    return (lookup);
}
sub vcl_hit {
    if (req.method == "purge") {
        return (synth(200, "purged."));
    }
    return (deliver);
}
sub vcl_miss {
  if (req.method == "purge") {
        return (synth(404, "purged."));
    }
    return (fetch);
}
sub vcl_deliver {
    if (obj.hits > 0) {
        set resp.http.cxk = "hit-from-varnish";
        set resp.http.x-cache-hits = obj.hits;
    } else {
    set resp.http.x-cache = "miss";
    }
    unset resp.http.x-powered-by;
    unset resp.http.server;
    unset resp.http.x-drupal-cache;
    unset resp.http.via;
    unset resp.http.link;
    unset resp.http.x-varnish;
    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_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
//啟動服務

第一臺web提供頁面

[root@localhost ~]# yum -y install httpd
[root@localhost ~]# echo aaa > /var/www/html/index.html
[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# systemctl start httpd

第二臺

[root@localhost ~]# yum -y install httpd
[root@localhost ~]# echo bbb > /var/www/html/index.html
[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# systemctl start httpd

如果重啟varnishd如下：

[root@localhost /]# netstat -anpt | grep 80
[root@localhost /]# killall -9 varnishd
[root@localhost /]# varnishd -f /usr/local/var/varnish/example.vcl -s malloc,200m -a 0.0.0.0:80

客戶端訪問如下：

刷新一下

[root@localhost /]# curl -x "purge" 192.168.148.130
//清除緩存

varnish配置文件解釋

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

感謝各位的閱讀，以上就是“基于Centos7怎么部署Varnish緩存代理服務器”的內容了，經過本文的學習后，相信大家對基于Centos7怎么部署Varnish緩存代理服務器這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！