'Nginx反向代理，負載均衡，redis session共享，keepalived高可用'

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

所以，只需要讓該腳本一直執行，即一直檢測nginx進程是否在，如果沒得了，那麼直接停止主機keepalived，切換備機，保證能夠訪問web服務器。

按如下修改keepalived配置文件keepalived.conf，添加腳本定義檢測：

只需要在正確的位置添加紅色部分即可：那麼腳本則是兩秒執行一次，一旦發現主機nginx不在了，keepalived停止，切換備機

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

所以，只需要讓該腳本一直執行，即一直檢測nginx進程是否在，如果沒得了，那麼直接停止主機keepalived，切換備機，保證能夠訪問web服務器。

按如下修改keepalived配置文件keepalived.conf，添加腳本定義檢測：

只需要在正確的位置添加紅色部分即可：那麼腳本則是兩秒執行一次，一旦發現主機nginx不在了，keepalived停止，切換備機

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

所以，只需要讓該腳本一直執行，即一直檢測nginx進程是否在，如果沒得了，那麼直接停止主機keepalived，切換備機，保證能夠訪問web服務器。

按如下修改keepalived配置文件keepalived.conf，添加腳本定義檢測：

只需要在正確的位置添加紅色部分即可：那麼腳本則是兩秒執行一次，一旦發現主機nginx不在了，keepalived停止，切換備機

保存後，重新啟動主機keepalived服務即可。

測試：

回到負載均衡高可用的初始狀態，保證主、備上的keepalived、nginx全部啟動。

停止主nginx服務：

主機查看keepalived進程，發現沒有，說明已經停止了，虛擬ip也沒有綁在主機上

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

所以，只需要讓該腳本一直執行，即一直檢測nginx進程是否在，如果沒得了，那麼直接停止主機keepalived，切換備機，保證能夠訪問web服務器。

按如下修改keepalived配置文件keepalived.conf，添加腳本定義檢測：

只需要在正確的位置添加紅色部分即可：那麼腳本則是兩秒執行一次，一旦發現主機nginx不在了，keepalived停止，切換備機

保存後，重新啟動主機keepalived服務即可。

測試：

回到負載均衡高可用的初始狀態，保證主、備上的keepalived、nginx全部啟動。

停止主nginx服務：

主機查看keepalived進程，發現沒有，說明已經停止了，虛擬ip也沒有綁在主機上

備機：綁定虛擬ip，切換成功。

"

作者：MrLinFeng;
原文：http://www.cnblogs.com/mrlinfeng/p/6146866.html

相關知識自行搜索，直接上乾貨。。。

使用的資源：

nginx主服務器一臺，nginx備服務器一臺，使用keepalived進行宕機切換。
tomcat服務器兩臺，由nginx進行反向代理和負載均衡，此處可搭建服務器集群。
redis服務器一臺，用於session的分離共享。
nginx主服務器：192.168.50.133
nginx備服務器：192.168.50.135
tomcat項目服務器1:192.168.50.137
tomcat項目服務器2:192.168.50.139
redis服務器：192.168.50.140

注意訪問時需要配置防火牆規則，或者關閉防火牆

首先進行的通用安裝：

總的需要模擬五臺服務器，使用vmware，全部使用centos6.5 64位，五臺服務器全部安裝jdk，我使用的是jdk1.8.

1、安裝VMware虛擬機，安裝linux系統，此處使用centOS6.5 64位，安裝linux命令行工具，上傳文件工具，此處使用SecureCRT，SecureFX 。安裝教程不再贅述，百度一大堆..........

2、在linux上安裝jdk:

安裝jdk：卸載openjdk版本，上傳解壓jdk，配置環境變量----參考：http://jingyan.baidu.com/article/ab0b56308966acc15afa7d18.html

一、Nginx反向代理與負載均衡：

架構圖：

此時需要用到三臺服務器，一臺nginx服務器，兩臺正式部署項目的服務器：選擇的是192.168.50.133主nginx和192.168.50.137,192.168.50.139兩臺tomcat服務器

首先在兩臺服務器上安裝tomcat：這個也是簡單，不多說

安裝tomcat：上傳解壓即可使用，bin目錄下 startup.sh啟動，shutdown.sh關閉

配置防火牆端口：vim /etc/sysconfig/iptables 編輯，開放8080端口，80端口等一些常用端口，當然後邊有用到一些端口都是需要配置開放的，不建議關閉防火牆

編輯好後 service iptables restart 重新加載防火牆配置

如果是自己測試嫌配置麻煩，關閉防火牆： service iptables stop 重啟後防火牆打開，即在此次開機狀態下有效，完全關閉再使用 chkconfig iptables off ,即會在重啟後也關閉防火牆，注意有時候服務都起了但訪問出錯，可能就是防火牆問題哦

啟動tomcat訪問：192.168.50.137:8080，192.168.50.139:8080，打開tomcat首頁即成功。

然後編寫測試項目，部署到兩臺tomcat上，eclipse新建web項目，項目名為testproject，在webapp下新建一個jsp頁面為index.jsp,添加如下內容

將項目中web.xml中的訪問順序index.jsp上移到第一個訪問

然後右鍵導出為war包，testproject.war，將該war包上傳到兩臺服務器的tomcat的webapps中

然後修改tomcat的server.xml文件，在tomcat conf目錄中：可以使用notepad++的插件NppFTP直接連上linux，然後使用notepad++修改文件哦，保存記得使用UTF-8無BOM格式，具體去百度吧，哈哈

修改Engine標籤中，添加jvmRoute，用於標識nginx訪問的是哪個服務器tomcat，137服務器標識為137Server1，139服務器標識為139Server2

在兩臺tomcat的server.xml文件，Host標籤中添加：，path標識訪問路徑，docBase為項目名，表示訪問項目

此時，重新啟動tomcat，訪問192.168.50.137:8080，192.168.50.139:8080,顯示index.jsp內容：兩臺服務器訪問顯示如下

至此，兩臺tomcat服務器搭建完成。

在nginx主機192.168.50.133上安裝nginx：

先使用yum命令安裝gcc，安裝pcre，zlib，openssl：

yum install -y gcc 
yum install -y pcre pcre-devel 
yum install -y zlib zlib-devel 
yum install -y openssl openssl-develplain

在/usr/local/目錄下新建nginx-src目錄，將nginx-1.8.0.tar.gz放到此處，解壓

tar -zxvf nginx-1.8.0.tar.gz

進入解壓後目錄

依次執行命令：

./configure make mkae install

此時nginx安裝完畢，安裝目錄是/usr/local/nginx，nginx默認佔用80端口

其中，sbin目錄為nginx執行命令，conf目錄下的nginx.conf為默認加載的配置文件

啟動nginx：

./sbin/nginx

關閉nginx：

./sbin/nginx -s stop

啟動nginx後訪問192.168.50.133:80即可訪問nginx：顯示nginx歡迎頁

至此，nginx安裝完畢。

3、反向代理與負載均衡配置

現有兩臺服務器，一臺為192.168.50.137，一臺為192.168.50.139，服務器上各有一臺tomcat，端口均為8080，在192.168.50.133上有nginx，經過配置nginx，當訪問192.168.50.133:80時，即可訪問192.168.50.137:8080，192.168.50.139:8080中隨機一臺，此時192.168.50.133:80被nginx監聽，當有請求時，代理到192.168.50.137:8080，192.168.50.139:8080隨機一臺即可。

即為nginx反向代理功能，同時此時可以通過nginx將請求進行轉發，保證了一個入口，將所有請求轉發到兩臺服務器上也減輕了任何一臺的負載壓力，當有大量請求時，可以搭建大量服務器，在入口代理服務器上使用nginx進行轉發，即是負載均衡功能。

配置即是配置nginx安裝目錄中conf目錄下的nginx.conf文件即可：具體配置如下，

啟動兩臺tomcat，重新啟動nginx：

訪問192.168.50.133:80將會隨機訪問192.168.50.137:8080和192.168.50.139:8080其中一臺。（問題：每次刷新nginx服務器地址sessionid會變，session不能共享。）

nginx輪詢策略：

nginx負載均衡到多臺服務器上時，默認採用輪詢策略：

常見策略：

1、輪詢

每個請求按時間順序逐一分配到不同的後端服務器，如果後端服務器down掉，能自動剔除。

2、weight

指定輪詢機率，weight和訪問比率成正比，用於後端服務器性能不均的情況，數字越大命中率越高。

例如：輪詢機率是2:1

upstream bakend {
server 192.168.0.14 weight=2;
server 192.168.0.15 weight=1;
}

3、ip_hash

每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個後端服務器，可以解決session的問題。

例如：

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

其他策略可以自行查詢學習,nginx還有很多其他可配置項，靜態資源緩存，重定向等，想深入的童鞋請自行學習

nginx配置詳解：http://blog.csdn.net/tjcyjd/article/details/50695922

實際問題：雖然解決了，但是不是很理解，記錄一下

其中192.168.50.133:80是有外網映射的，外網55.125.55.55:5555映射到192.168.50.133:80上，此時使用55.125.55.55:5555訪問，會映射到192.168.50.133:80上，然後會被轉發到192.168.50.137:8080或192.168.50.139:8080，但是此時卻出現圖片，js，css等靜態文件無法訪問的情況，通過兩種方法解決。

<1>.映射非80端口

讓55.125.55.55:5555映射192.168.50.133的非80端口，例如55.125.55.55:5555映射192.168.50.133:5555，然後再在nginx配置文件中配置如下：這地方不理解

此時訪問55.125.55.55:5555，映射到192.168.50.133:5555上，然後轉發到192.168.50.137:8080或192.168.50.139:8080上，此時靜態文件均能訪問。

<2>.使用域名在外網服務器上使用nginx進行轉發

將55.125.55.55綁定域名為test.baidubaidu.com，此時在55.125.55.55服務器上使用nginx,

以上即nginx反向代理與負載均衡介紹，經過此次學習，發現nginx確實是博大精深，一個配置文件搞得我不要不要的。。。

二、session共享問題：

由於nginx是隨機分配請求，假設一個用戶登錄時訪問網站登錄時被分配到192.168.50.137:8080上，然後進行了登錄操作，此時該服務器上就會有該用戶登錄的session信息，然後登陸後重定向到網站首頁或個人中心時，此時如果被分配到192.168.50.139:8080上，那麼這臺服務器上沒有該用戶session信息，於是又會變成未登錄狀態，所以由於nginx的負載均衡會導致session共享的問題。

解決方法：

1、nginx提供了ip_hash策略，可以保持用戶ip進行hash值計算固定分配到某臺服務器上，然後只要是該ip則會保持分配到該服務器上，保證用戶訪問的是同一臺服務器，那麼session問題就不存在了。這也是解決session共享的一種方式，也稱為黏性session。但是假設一臺tomcat服務器掛了的話，那麼session也會丟失。所以比較好的方案是抽取session。

2、session存在memcache或者redis中，以這種方式來同步session，把session抽取出來，放到內存級數據庫裡面，解決了session共享問題，同時讀取速度也是非常之快。

本例中：

Redis解決session共享：

在redis服務器192.168.50.140上搭建redis，redis默認端口為6379

Redis搭建：

redis依賴gcc，

1，先安裝：

yum install -y gcc-c++

2，下載redis，我使用的是redis-3.2.1.tar.gz，上傳至linux /usr/local/redis-src/中。

3，解壓。

4，進入解壓後目錄redis-3.2.1，執行make命令進行編譯。

5，安裝到目錄/usr/local/redis。

6，執行：

make PREFIX=/usr/local/redis install

安裝完成之後將redis配置文件拷貝到安裝目錄下，redis.conf是redis的配置文件，redis.conf在redis源碼目錄，port默認6379。

7，執行命令：

cp /usr/local/redis-src/redis-3.2.1/redis.conf /usr/local/redis/

在redis安裝目錄啟動和關閉redis：

啟動：

./bin/redis-server ./redis.conf

這種啟動方式叫做前端啟動，必須保持在當前窗口，如果ctrl + c 退出，那麼redis也就退出了，不建議使用

那麼後端啟動：

首先修改redis.conf中daemonize的值，打開可以看到默認是no，修改為daemonize yes，啟動即可。也可以在該配置文件中修改redis默認端口6379為其他值。

關閉redis：

./bin/redis-cli shutdown

至此，redis服務器搭建完成。

tomcat與redis集成實現session共享：

環境為tomcat7 + jdk1.6的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，注意版本最好一致，不然極容易出現錯誤，下邊的測試是可用的：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"/> 
<Manager className="com.radiadesign.catalina.session.RedisSessionManager"
host="192.168.50.140"
port="6379"
database="0" 
maxInactiveInterval="60" />

環境為tomcat7 + jdk1.7或1.8的話：

在所有需要共享session的服務器的tomcat中目錄下：

lib目錄中添加以下三個jar包，測試通過：

conf目錄中content.xml中加入：配置redis服務

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
host="192.168.50.140" 
port="6379" 
database="0" 
maxInactiveInterval="60"/>

根據我這測試，是jkd1.8+tomcat7，在137和139兩臺tomcat中加入jar包且進行如上配置：

上傳jar包

修改content.xml

啟動redis服務，重新啟動所有tomcat，啟動nginx，刷新nginx頁面,兩臺tomcat頁面可以看到sessionid值不變，關閉某臺tomcat，nginx中sessionid不變，說明session是共享的。

問題：

有可能此時訪問會報錯，redis無法訪問，這是由於redis的安全機制，默認只有127.0.0.1才能訪問，在redis.conf中可以找到bind 127.0.0.1，你可以將此ip改為訪問者ip；

如果有多個訪問者，也可以把bind 127.0.0.1註釋掉，然後在配置文件中找到protected-mode，修改protected-mode yes改為protected-mode no 關閉redis保護模式即可，詳細可以參考這：http://www.cnblogs.com/liusxg/p/5712493.html

經過大牛指點：添加兩個注意點：

1、按照如上配置,使用redis數據庫,放入session中的對象必須要實現java.io.Serializable接口，使用memcache的可以不用實現Serializable接口

原因是:因為tomcat裡使用的將session放置redis使用的工具類,是使用的jdk序列化模式存儲的，這一點也是很容易理解的，session.setAttribute(String key, Object value)，存儲Object類型。

object放入redis中又要能取出來，只能是序列化進行存儲了，然後取出的時候進行反序列化。

所以我們在session中存儲的任何對象，都必須實現序列化接口。

2、按照如上配置,使用redis做session存儲空間時,web應用的session-time的時間單位會變成[秒],而不是原本的[分]

原因是:因為tomcat裡使用的將session放置redis使用的工具類,在存儲時為對tomcat容器時間做轉換。

在redis中設置過期時間是使用秒作為單位的，有個命令叫expire可以設置redis鍵值過期時間，所以在context.xml配置文件中我們需要制定session過期時間（默認是60秒，配成1800即30分鐘），這一點很重要。

請注意！！！！

context.xml配置說明：

<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" /> 
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"
//這裡是redis服務器地址
host="192.168.50.140"
//這裡是redis端口，redis默認端口是6379
port="6379"
//這裡是redis數據庫中的標識，標識第0個，默認使用0即可
database="0" 
//需要注意的是這裡由於redis過期時間默認設置為60，單位是秒，session過期時間為30分鐘，所以需要設置為1800對應30分鐘
maxInactiveInterval="1800"/>

三、keepalived高可用：

架構圖：

上圖畫的不對稱好難看，將就下吧

根據上邊一路走來，已經是搭好了從nginx主到服務器的這條線的，那麼同理，使用nginx備機192.168.50.135上再搭建nginx，也是代理192.168.137和139兩臺服務器。搞了一次之後也就簡單了

在192.168.50.135上安裝nginx，配置nginx配置即可，不再贅述，nginx備機配置如下：

配置和上邊的是一樣的，只不過監聽的地方的ip了而已

那麼現在就是相當於有兩套nginx了，代理的服務器是一樣的，為什麼要搞兩套？

假設只有一臺nginx的話，這個nginx服務器掛了。那怎麼辦？

所以需要一臺備份nginx。

正常情況下，主nginx作為反向代理服務器即可，假設nginx服務器掛了的話，能夠立即切換到備份機上，保證用戶可以訪問，然後運維人員把主nginx服務器故障修好之後，又能夠自動切換到主nginx提供服務。通過keepalived來監測兩臺服務器，正常情況時，將nginx主服務器ip（192.168.50.133）綁定到keepalived定義的一個虛擬ip（我設置為192.168.50.88）上，通過這個虛擬IP可以訪問nginx，然後備機（192.168.50.135）啥事不幹，就是每隔一小段時間（設置為1秒）keepalived會告訴備機，你不用管，我還活著呢，如果突然主機死了，那麼就會超過一秒備機沒有收到主機或者的消息，那麼備機馬上接管主機，keeplived將虛擬ip綁定到備機身上，網站繼續提供服務。

突然主機又復活了（運維人員排除故障了），那麼備機又將收到主機的活著的消息，於是將管理權交回給主機，虛擬ip又綁到主機上，大概就是這麼個過程，個人理解。

先在兩臺nginx服務器（主備）上都裝上keepalived：

下載：這裡使用rpm安裝，是區分32,64位的，不要搞錯了哦

keepalived-1.2.7-3.el6.x86_64.rpm

openssl-1.0.1e-30.el6_6.4.x86_64.rpm

要求必須是openssl-1.0.1e或以上才行、如果版本已經符合（因為安裝nginx時已經安裝openssl，使用yum安裝應該是符合的）、不用再安裝openssl，使用 rpm -q openssl 查看當前openssl版本，我這已經是1.0.1e 48的，所以就不安裝了

將兩個rpm安裝包上傳到兩臺nginx服務器，進入上傳到的目錄，運行以下命令安裝:--nodeps是忽略依賴包，當然最好是把依賴包裝上，去掉--nodeps可以看到錯誤，需要哪些依賴包

如果需要安裝openssl

rpm –Uvh --nodeps ./openssl-1.0.1e-30.el6_6.4.x86_64.rpm

安裝keepalived：

rpm -Uvh --nodeps ./keepalived-1.2.7-3.el6.x86_64.rpm

安裝完畢後再/etc/keepalived/目錄下有個文件 keepalived.conf即是本臺服務器keepalived的核心配置文件了：

重點：keepalived配置，配置文件上邊部分按照下面的配置就行了，配置文件後面的內容可以不用管，還沒有去研究其他部分

先配置主機192.168.50.133的keepalived，按下邊進行配置

備機192.168.50.135的keepalived配置：

備機配置注意的地方：需要修改state為BACKUP , priority比MASTER低，virtual_router_id和master的值一致

醬紫，keepalived就配置完成了。

keeplived啟動關閉命令：

service keepalived start 
service keepalived stop 
service keepalived start 
service keepalived stop

啟動兩臺nginx，啟動主機keepalived，啟動備機keepalived服務。

這時，nginx主機在提供服務，備機是閒著的，虛擬ip是192.168.50.88，在主機和備機上使用命令

ip addr

可以發現：

主機：可以看到，192.168.50.133 帶有虛擬ip192.168.50.88，在瀏覽器中輸入192.168.50.88，即可訪問到主nginx192.168.50.133.然後轉發到tomcat服務器上

瀏覽器訪問虛擬ip：192.168.50.88，效果如下

備機：ip addr命令執行：可以看到，備機nginx沒有綁定虛擬ip

以上是初始狀態下的情況，也是正常服務的情況。

現在測試高可用，假設主機nginx服務器掛了，模擬為關閉nginx主機或者將keepalived服務停止，那麼主機上keepalived死了就沒辦法告訴備機自己活著，而備機超過1秒沒有接收到主機給自己的消息，馬上接管虛擬ip，同時在配置文件中配置切換主備機時發送郵件，此時開發團隊收到郵件即知道主機掛了，馬上去排除主機的故障。

將主機上的keepalived服務停止，service keepalived stop ,然後查看虛擬ip綁定情況，主機掛了：可以看到虛擬ip就沒有綁在主機上

備機情況：虛擬ip已經綁定到備機，此時主機雖然掛了，但是切換到備機上了（發現故障和切換的時間差最大也就是1秒），虛擬ip也綁到備機上了，訪問虛擬ip，就會請求備機nginx然後轉發到web服務器實現高可用。

運維人員收到郵件後就去排除主機故障了，搞定之後（模擬為keepalived服務啟動），這時主機告訴備機，我又活了，於是備機將管理權又交給主機（切換為主機nginx提供服務）：

主機keepalived服務啟動後，即吧主機維護好之後：可以看到，虛擬ip又自動綁到了主機上

備機情況，主機活了之後，備機轉交管理權，虛擬ip切換到主機上，備機不綁定虛擬ip,貌似啟動keepalived服務之後並不能馬上切回，應該是起服務需要點時間吧，但是不影響，這段時間還是備機綁定虛擬IP的

這就是keepalived高可用的模擬。

注意問題：

主機掛了之後，主機nginx恢復時，一定要將nginx也啟動，否則即使虛擬ip切換到了主機上，但是主機nginx沒起那也是沒法轉發的。所以要把nginx啟動要加在開機啟動中。

四、Nginx服務開機自啟動：

在linux系統的/etc/init.d/目錄下創建nginx文件，使用如下命令：（vim命令不會的自己去學吧哈哈）

vi /etc/init.d/nginx

將如下內容搞到該文件中:注意紅色部分修改成你的路徑即可，nginxd值是啟動nginx的nginx路徑，nginx_config值是nginx配置文件nginx.conf路徑，nginx_pid值是nginx.pid所在路徑，如果按照我方法安裝的話，是在nginx安裝目錄的logs裡邊的

然後設置該文件的訪問權限：執行以下命令，意為所有用戶可訪問

chmod a+x /etc/init.d/nginx

最後將ngix加入到rc.local文件中，這樣開機的時候nginx就默認啟動了

vi /etc/rc.local

添加

/etc/init.d/nginx start

保存並退出，下次重啟就會生效，nginx的開機自啟動。測試無誤的。

五、解決nginx進程和keepalived不同時存在問題:

keepalived是通過檢測keepalived進程是否存在判斷服務器是否宕機，如果keepalived進程在，但是nginx進程不在了，那麼keepalived是不會做主備切換。因為是nginx掛了，然後無法做代理，keepalived還在不會切換到備機。

所以一直檢測nginx是否還在，如果不在，那麼讓keepalived也停止，同生共死。

注：只需要在主機上搞就行了，備機沒必要檢測nginx，因為基本是主機在服務。

解決：寫個腳本來監控nginx進程是否存在，如果nginx不存在就將keepalived進程殺掉。

注：keepalived不需要開機啟動，假如開機自啟的話，如果keepalived比nginx 更快啟動的話，腳本檢測會把keepalived停掉的，所以沒必要，只需要nginx開機啟動，啟動主機後自行手動的把keepalived服務啟動即可。

在主nginx上編寫nginx進程檢測腳本（check_nginx_dead.sh）,在keepalived配置文件目錄下創建腳本:

vi /etc/keepalived/check_nginx_dead.sh

把下邊這些內容搞到腳本文件中，內容如下：

#!/bin/bash
# 如果進程中沒有nginx則將keepalived進程kill掉
A=`ps -C nginx --no-header |wc -l` 
## 查看是否有 nginx進程 把值賦給變量A
if [ $A -eq 0 ];then 
## 如果沒有進程值得為 零
 service keepalived stop 
 ## 則結束 keepalived 進程
fi

給訪問權限：不然不行哦，這裡卡了我半小時

chmod a+x /etc/keepalived/check_nginx_dead.sh

先測試一下腳本：

把nginx停了，此時keepalived還在運行，所以不會切換，虛擬ip無法訪問到web服務器

然後執行腳本：

主機腳本檢測nginx不在了，把keepalived停掉，從輸出可以看到確實停止了，主機虛擬沒有綁定虛擬ip

備機：成功綁定虛擬ip

所以，只需要讓該腳本一直執行，即一直檢測nginx進程是否在，如果沒得了，那麼直接停止主機keepalived，切換備機，保證能夠訪問web服務器。

按如下修改keepalived配置文件keepalived.conf，添加腳本定義檢測：

只需要在正確的位置添加紅色部分即可：那麼腳本則是兩秒執行一次，一旦發現主機nginx不在了，keepalived停止，切換備機

保存後，重新啟動主機keepalived服務即可。

測試：

回到負載均衡高可用的初始狀態，保證主、備上的keepalived、nginx全部啟動。

停止主nginx服務：

主機查看keepalived進程，發現沒有，說明已經停止了，虛擬ip也沒有綁在主機上

備機：綁定虛擬ip，切換成功。

測試通過，如果主機nginx掛了之後，keepalived也會隨著掛掉，然後切換備機。

以上所有過程均是經過測試的，所以除去一些其他因素，例如人品，應該都是可以成功的。

"

相關推薦

'深入淺出反向代理服務器“Nginx”'

"首先我們先了解一下Nginx是什麼Nginx ("engine x") 是一個高性能的HTTP和反向代理 服務器,特點是佔有內存少，併發能力強，事實上nginx的 併發能力確實在同類型的網頁服務器中表現較好，中國 大陸使用nginx網站用戶有：百度、京東、新浪、網易、 騰...

Nginx Tomcat 中央處理器 Java PHP Redis 2019-08-30

'什麼是負載均衡？什麼是高可用？說說常見的負載均衡案例'

"一、 什麼是負載均衡？什麼是負載均衡？記得第一次接觸 Nginx 是在實驗室，那時候在服務器部署網站需要用 Nginx 。Nginx 是一個服務組件，用來反向代理、負載平衡和 HTTP 緩存等。那麼這裡的 負載均衡 是什麼？負載均衡（LB，Load Balance），是一...

Nginx Java MySQL 算法 DNS 技術 瀏覽器 Node.js Redis 2019-08-22

'注意這幾點，輕輕鬆鬆配置 Nginx + Tomcat 的集群和負載均衡'

"Tomcat 集群是當單臺服務器達到性能瓶頸，通過橫向擴展的方式提高整體系統性能的有效手段。Nginx 是一個高性能的 HTTP 和反向代理 web 服務器，可以通過簡單的配置實現 Tomcat 集群的負載均衡。本文使用的 Tomcat 是 8.5.35 版本，Nginx...

Nginx Tomcat 數據庫 Windows HTML Scheme Redis 2019-08-21

'“正向代理”和“反向代理”你還傻傻分不清？'

"我家老闆看過這篇文章之後的評價是：寫的不錯，語句是通順的，排版是可以的，但反向代理是什麼還是不清楚。所以我就嘗試著向非 IT 工作者解釋“正向代理”和“反向代理”。接下來我會先嚐試面向大眾，來解釋“代理”的概念，再從專業的角度解釋“正向代理”和“反向代理”。概念實例化在講...

Nginx Google GFW 軟件 編程語言 跳槽那些事兒 通信 2019-08-14

'大白話 - Nginx 負載均衡的幾種算法'

"引言 對於應用程序來說，隨著數據量與訪問量越來越大，傳統的單體架構往往已經不能滿足高負載，高併發的需求了。架構往往會由最初的單體架構，演變為高可用的架構。那麼，負載均衡幾乎又是其架構中必不可少的一部分。nginx 負載均衡器的使用 由於nginx 的epoll 工作模式，...

Nginx 算法 Apache HTML 軟件 硬件 2019-08-13

'Nginx詳解（正向代理、反向代理、負載均衡原理）'

"nginx概述nginx是一款自由的、開源的、高性能的HTTP服務器和反向代理服務器；同時也是一個IMAP、POP3、SMTP代理服務器；nginx可以作為一個HTTP服務器進行網站的發佈處理，另外nginx可以作為反向代理進行負載均衡的實現。這裡主要通過三個方面簡單介紹...

Nginx 軟件 算法 硬件 阿迪達斯 設計 技術 瀏覽器 中國移動 2019-08-04

'淺談一個網頁打開的全過程（涉及DNS、CDN、Nginx負載均衡等）'

"淺談一個網頁打開的全過程（涉及DNS、CDN、Nginx負載均衡等）1、概要從用戶在瀏覽器輸入域名開始，到web頁面加載完畢，這是一個說複雜不復雜，說簡單不簡單的過程，下文暫且把這個過程稱作網頁加載過程。下面我將依靠自己的經驗，總結一下整個過程。如有錯漏，歡迎指正。閱讀本...

Nginx DNS Windows Chrome 操作系統 HTML 瀏覽器 設計 Apache CSS Linux 讀書 2019-07-31

Nginx實現高可用

一、課程目標Nginx介紹Ningx應用場景Windows環境下安裝NginxWindows環境下實現反向代理Windows環境下實現負載均衡Nginx實...

Nginx Windows Linux HTML Tomcat 設計師 中央處理器 2019-07-01

即時通訊新手入門：什麼是Nginx？它能否實現IM的負載均衡？

本文引用了“薔薇Nina”的“Nginx 相關介紹(Nginx是什麼?能幹嘛?)”一文部分內容，感謝作者的無私分享。1、引言Nginx（及其衍生產品）是目...

Nginx Apache 自由軟件 Linux 技術 操作系統 設計 IBM AIX 算法 中央處理器 騰訊 C語言 歷史 FreeBSD 文章 Mac電腦 工程師 Solaris 2019-06-10

除了負載均衡，Nginx還可以做很多，限流、緩存、黑白名單等

Nginx應該是現在最火的web和反向代理服務器，沒有之一。她是一款誕生於俄羅斯的高性能web服務器，尤其在高併發情況下，相較Apache，有優異的表現。...

Nginx 算法 Apache 瀏覽器 2019-05-31

基於Docker + Consul + Nginx + Consul-Template的服務負載均衡

前言上一篇文章使用 Consul 和 Registrator 在 docker 的容器環境中搭建了服務註冊和發現集群。在服務發現和註冊的基礎上，本文將引入...

Nginx Docker WebApp 操作系統 軟件 Ubuntu 2019-05-29

Nginx實現請求的負載均衡 + keepalived實現Nginx的高可用

前言使用集群是網站解決高併發、海量數據問題的常用手段。當一臺服務器的處理能力、存儲空間不足時，不要企圖去換更強大的服務器，對大型網站而言，不管多麼強大的服...

Nginx Tomcat 瀏覽器 JavaScript XML CentOS 技術 VirtualBox CSS 中央處理器 2019-05-21

Nginx 動靜分離與負載均衡的實現

一、前提 企業中，隨著用戶的增長，數據量也幾乎成幾何增長，數據越來越大，隨之也就出現了各種應用的瓶頸問題。 問題出現了，我們就得想辦法解決，一般網站環境，...

Nginx PHP Apache 數據庫 Vim SQL 網絡拓撲 MySQL 虛擬機 2019-04-15

10年老程序猿淺談Nginx負載均衡

一 特點1.1 應用情況Nginx做為一個強大的Web服務器軟件，具有高性能、高併發性和低內存佔用的特點。此外，其也能夠提供強大的反向代理功能。俄羅斯大約...

Nginx 程序員 算法 SPDY 2019-04-14

nginx搭建簡易負載均衡服務

什麼是負載均衡 當一臺服務器的性能達到極限時，我們可以使用服務器集群來提高網站的整體性能。那麼，在服務器集群中，需要有一臺服務器充當調度者的角色，用戶的所...

Nginx PHP CentOS Docker 虛擬機 Vi Windows 2019-04-08

【漫畫】如何給女朋友解釋什麼是反向代理？

作者：漫話編程公眾號：漫話編程週末，我正在網上搜索簡歷，準備給團隊招聘新人。這時候，女朋友回來了，看起來並不是很高興。反向代理（reverse proxy...

租房 軟件 漫畫 防火牆 技術 2019-04-07

Nginx負載均衡，實現我們網站的高可用性

當我們的網站處於發展初期的時候，nginx只代理了後端一臺服務器，但由於我們網站名氣大漲訪問的人越來越多一臺服務器實在是頂不住，於是我們加了多臺服務器，那...

Nginx 算法 Vim 2019-04-07

藉助Nginx搭建反向代理服務器

一、反向代理：Web服務器的“經紀人”1.1 反向代理初印象反向代理（Reverse Proxy）方式是指以代理服務器來接受internet上的連接請求，...

Nginx Java Linux 操作系統 BSD OS X 程序員 軟件 UNIX Apache Windows Discuz! 技術 Solaris 俄羅斯 Mac電腦 搜索引擎 迅雷 六間房 播客 2019-04-07

TCP接入層的負載均衡、高可用、擴展性架構設計

一、web-server的負載均衡互聯網架構中，web-server接入一般使用nginx來做反向代理，實施負載均衡。整個架構分三層：上游調用層，一般是b...

DNS Nginx Apache 技術 2018-12-17

跨域問題，解決方案-Nginx反向代理

跨域問題，解決之道跨域問題，在日常開發過程中，是一個非常熟悉的名詞。今天的話題，結合我之前的項目場景，討論下《跨域問題，解決之道》。跨域是什麼跨域問題，是...

編程語言 Nginx Java JavaScript JSON 2018-12-01

推薦中...