DInG_BloG

Nginx Rewrite和Return

2020-02-18T15:16:20.000Z

[TOC]

Rewrite配置（一）

nginx的rewrite配置是nginx配置中比较核心的部分，rewrite可以实现域名跳转（重定向）、URL重写（伪静态）、动静分离（跳转域名，并接入CDN实现加速）。rewrite依赖pcre库，用到的模块是ngx_http_rewrite_module。

rewrite相关指令

if指令

格式： if （条件判断） { 具体的rewrite规则 }

条件举例
1. 条件判断语句有nginx内置变量、逻辑判断符号和目标字符串三部分组成。
2. 其中，内置变量是nginx固定的非自定义的变量，如$request_method、$request_uri等。
3. 逻辑判断符号有 =、!=、~、~、!~、!~。
4. !表示取反，~为匹配符号，它右侧为正则表达式，区分大小写，而~*为不区分大小写匹配。
5. 目标字符串可以是正则表达式，通常不用加引号，但表达式中有特殊符号时，比如空格、花括号、分号等，需要用单引号引起来。

示例1：

if ($request_method = POST)     # 当请求的方法为POST时，直接返回405状态码。if中支持用return指令。
{
    return 405；
}

示例2：

if ($http_user_agent ~ MSIE )    # 当user_agent带有MSIE（IE浏览器）字符的请求，直接返回403状态码。
{
    return 403；
}

如果想同时限制多个user_agent，还可以写成这样：

if ($http_user_agent ~ "MSIE|firefox|spider")
{
    return 403；
}

示例3：

if (!-f $request_filename)      # 当请求的文件不存在时，将会执行下面的rewrite规则。
{
    rewrite 语句；
}

示例4：

if ($request_uri ~* 'gid=\d{9,12}/')  # \d表示数字，{9,12}表示数字出现的次数是9到12次，比如gid=123456789是符合条件的，就会执行下面的rewrite规则。
{
    rewrite 语句；
}

break和last指令

两个指令用法相同，但含义不同，需要放到rewrite规则的末尾，用来控制重写后的链接是否继续被nginx配置执行（主要是rewrite、return指令）。

示例1：

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;                 #打开rewrite日志，在error.log中
    rewrite /1.html /2.html;
    rewrite /2.html /3.html;
}

访问测试：

1 2	curl -x127.0.0.1:80 www.1.com/1.html 333333 # 说明已经从1.html跳转到3.html，实际访问到的是3.html。

查看日志:

2020/02/18 15:58:35 [notice] 4229#0: *56 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 15:58:35 [notice] 4229#0: *56 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 15:58:35 [notice] 4229#0: *56 "/2.html" matches "/2.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 15:58:35 [notice] 4229#0: *56 rewritten data: "/3.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

示例2：

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;
    rewrite /1.html /2.html break;
    rewrite /2.html /3.html;
}

访问测试：

1 2	curl -x127.0.0.1:80 www.1.com/1.html # 说明这一次是从1.html跳转到2.html，没有继续往下面跳转。 222222

查看日志:

1
2

2020/02/18 16:15:51 [notice] 4522#0: *60 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:15:51 [notice] 4522#0: *60 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

示例3：

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;
    rewrite /1.html /2.html last;
    rewrite /2.html /3.html;
}

访问测试:

1 2	curl -x127.0.0.1:80 www.1.com/1.html # 说明这一次也是从1.html跳转到2.html，没有继续往下面跳转。在server部分配置break和last作用一致 222222

查看日志:

1
2

2020/02/18 16:15:51 [notice] 4522#0: *60 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:15:51 [notice] 4522#0: *60 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

示例4：

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    location / {
    rewrite /1.html /2.html;
    rewrite /2.html /3.html;
    }

    location /2.html {
    rewrite /2.html /a.html;
    }

    location /3.html {
    rewrite /3.html /b.html;
    }
}

访问测试:

curl -x127.0.0.1:80 www.1.com/1.html


404 Not Found
"white">
404 Not Found
nginx

查看日志:

2020/02/18 16:23:04 [notice] 4564#0: *64 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 "/2.html" matches "/2.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 rewritten data: "/3.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 "/3.html" matches "/3.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 rewritten data: "/b.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 "/1.html" does not match "/b.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [notice] 4564#0: *64 "/2.html" does not match "/b.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:23:04 [error] 4564#0: *64 open() "/data/wwwroot/www.1.com/b.html" failed (2: No such file or directory), client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

首先匹配到1.html，1.html跳转到2.html；再匹配到2.html，2.html又跳转到3.html；接下来匹配到3.html，3.html跳转到b.html；b.html还会继续匹配，但没有匹配到，所以访问b.html，因为b.html不存在，所以返回404状态码。

示例5：

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    location / {
    rewrite /1.html /2.html break;
    rewrite /2.html /3.html;
    }

    location /2.html {
    rewrite /2.html /a.html;
    }

    location /3.html {
    rewrite /3.html /b.html;
    }
}

访问测试:

1 2	curl -x127.0.0.1:80 www.1.com/1.html 222222

查看日志:

1
2

2020/02/18 16:26:02 [notice] 4608#0: *1 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:26:02 [notice] 4608#0: *1 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

可以看到，只rewrite一次，从1.html跳转到2.html就直接退出，后面的location部分也不再执行了。

示例6:

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    location / {
    rewrite /1.html /2.html last;
    rewrite /2.html /3.html;
    }

    location /2.html {
    rewrite /2.html /a.html;
    }

    location /3.html {
    rewrite /3.html /b.html;
    }
}

访问测试:

curl -x127.0.0.1:80 www.1.com/1.html


404 Not Found
"white">
404 Not Found
nginx

查看日志：

2020/02/18 16:27:02 [notice] 4614#0: *2 "/1.html" matches "/1.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [notice] 4614#0: *2 rewritten data: "/2.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [notice] 4614#0: *2 "/2.html" matches "/2.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [notice] 4614#0: *2 rewritten data: "/a.html", args: "", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [notice] 4614#0: *2 "/1.html" does not match "/a.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [notice] 4614#0: *2 "/2.html" does not match "/a.html", client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"
2020/02/18 16:27:02 [error] 4614#0: *2 open() "/data/wwwroot/www.1.com/a.html" failed (2: No such file or directory), client: 127.0.0.1, server: www.1.com, request: "GET HTTP://www.1.com/1.html HTTP/1.1", host: "www.1.com"

先从1.html跳转到2.html，因为有last，所以本location段内的下面的内容不再执行，但是会继续执行下面的location段，最后匹配到2.html（因为比 / 更精准），从2.html跳转到a.html，因为a.html不存在，所以返回404状态码。

综上，我们可以得到结论：

当rewrite规则在location{}外，break和last作用一样，遇到break或last后，其后续的rewrite/return语句不再执行。但后续有location{}的话，还会近一步执行location{}里面的语句,当然前提是请求必须要匹配该location。
当rewrite规则在location{}里，遇到break后，本location{}与其他location{}的所有rewrite/return规则都不再执行。
当rewrite规则在location{}里，遇到last后，本location{}里后续rewrite/return规则不执行，但重写后的url再次从头开始执行所有规则，哪个匹配执行哪个。

Nginx rewrite配置（二）

格式：rewrite regex replacement [flag]

rewrite配置可以在server、location以及if配置段内生效
regex是用于匹配的正则表达式，其不会匹配到$host（域名）
replacement是目标跳转的uri，可以以http://或https://开头，也可以省略掉$host，直接写$request_uri部分（即请求链接）
flag，用来设置rewrite对uri的处理行为，其中有break、last、redirect、permanent。redirect和permanent的区别在于，redirect是临时重定向（302），而permanent是永久重定向（301）。对于用户访问来说，两者效果一致；但对于搜索引擎爬虫来说，使用301更利于SEO。所以，建议replacement是以http://或https://开头的，flag使用permanent

示例1：

1
2
3

location / {
    rewrite /(.*) http://www.123.com/$1 permanent;  # 说明：.* 为正则表达式，用()括起来，在后面的URL中可以调用它，第一次出现的()用$1调用，第二次出现的()用$2调用，依次类推。
}

示例2:

1
2
3

location / {
    rewrite /.* http://www.123.com$request_uri permanent; # 说明：在replacement中，支持变量，这里的$request_uri就是客户端请求的链接。
}

示例3：

server {
    listen 80;
    service_name www.123.com;
    root /tmp/123.com;
    index index.html;
    rewrite /(.*) /abc/$1 redirect;  # 注明：本例中的rewrite规则有问题，会造成连续循环，而nginx有个最大50次限制，循环超过50次会失败。
}

修改配置：

vim /usr/local/nginx/conf/vhost/www.2.com.conf 

server {
    listen 80;
    server_name www.2.com;
    index index.html;
    root /data/wwwroot/www.2.com;

    location / {
        rewrite /(.*) /abc/$1 redirect;
    }
}

访问测试:

curl -x127.0.0.1:80 www.2.com/1.html


302 Found
"white">
302 Found
nginx



curl -x127.0.0.1:80 www.2.com/1.html -L
curl: (47) Maximum (50) redirects followed

url -x127.0.0.1:80 www.2.com/1.html -I

HTTP/1.1 302 Moved Temporarily
Server: nginx
Date: Mon, 22 Apr 2019 13:41:15 GMT
Content-Type: text/html
Content-Length: 154
Location: http://www.2.com/abc/1.html
Connection: keep-alive

curl -x127.0.0.1:80 www.2.com/abc/1.html -I

HTTP/1.1 302 Moved Temporarily
Server: nginx
Date: Mon, 22 Apr 2019 13:41:27 GMT
Content-Type: text/html
Content-Length: 154
Location: http://www.2.com/abc/abc/1.html
Connection: keep-alive

可以看到，一直在循环 /abc ，直到循环超过50次。

示例：4

server {
    listen 80;
    service_name www.123.com;
    root /tmp/123.com;
    index index.html;
    rewrite /(.*) /abc/$1 break;
}

说明：在rewrite中使用break，可以避免循环。

示例5:

server {
    listen 80;
    service_name www.123.com;
    root /tmp/123.com;
    index index.html;
    if ($request_uri !~ '^/abc/')   
    {
        rewrite /(.*) /abc/$1 redirect;
    }
}

说明：增加一个条件判断，也可以避免循环。

修改配置：

vim /usr/local/nginx/conf/vhost/www.2.com.conf 

server {
    listen 80;
    server_name www.2.com;
    index index.html;
    root /data/wwwroot/www.2.com;

    if ($request_uri !~ '^/abc/')
    {
        rewrite /(.*) /abc/$1 redirect;
    }
}

访问测试:

curl -x127.0.0.1:80 www.2.com/1.html -I

HTTP/1.1 302 Moved Temporarily
Server: nginx
Date: Mon, 22 Apr 2019 13:48:42 GMT
Content-Type: text/html
Content-Length: 154
Location: http://www.2.com/abc/1.html
Connection: keep-alive

# curl -x127.0.0.1:80 www.2.com/abc/1.html -I

HTTP/1.1 404 Not Found
Server: nginx
Date: Mon, 22 Apr 2019 13:50:21 GMT
Content-Type: text/html
Content-Length: 162
Connection: keep-alive

nginx全局变量

nginx常用全局变量：

变量	说明
$args	请求中的参数，如 www.123.com/1.php?a=1&b=2 的$args就是 a=1&b=2
$content_length	http请求信息里的“Content-Length”
$content_type	http请求信息里的“Content-Type”
$content_root	nginx虚拟主机配置文件中的 root参数对应的值
$document_uri	当前请求中不包含指令的URI，如 www.123.com/1.php?a=1&b=2 的 $document_uri 就是1.php，不包含后面的参数
$host	主机头，即域名
$http_user_agent	客户端的详细信息，也就是浏览器的标识，用curl -A可以指定
$http_cookie	客户端的cookie信息
$limit_rate	如果nginx服务器使用limit_rate配置了显示网络速率，则会显示，没有设置则显示为0
$remote_addr	客户端公网ip
$remote_port	客户端的port
$remote_user	如果nginx有配置认证，该变量代表客户端认证的用户名
$request_body_file	做反向代理时发给后端服务器的本地资源的名称
$request_method	请求资源的方式，GET/PUT/DELETE等
$request_filename	当前请求的资源文件的路径名称，相当于是 $document_root/$document_uri 的组合
$request_uri	请求的链接，包括 $document_uri 和 $args
$scheme	请求的协议，如ftp,http,https
$server_protocol	客户端请求资源使用的协议的版本，如HTTP/1.0，HTTP/1.1，HTTP/2.0等
$server_addr	服务器IP地址
$server_name	服务器的主机名
$server_port	服务器的端口号
$uri	和$document_uri相同
$http_referer	客户端请求时的referer，通俗讲就是该请求是通过哪个链接跳过来的，用curl -e可以指定

return用法

return指令一般用于对请求的客户端直接返回响应状态码。在该作用域内return后面的所有nginx配置都是无效的。可以使用在server、location以及if配置中。

除了支持跟状态码，还可以跟字符串和url链接。

返回状态码

示例1:

server {
    listen 80;
    server_name www.1.com;
    return 403;
    rewrite /(.*) /abc/$1;               #该行配置不会被执行
}

. 表示所有，$1表示前面的.

vim /usr/local/nginx/conf/vhost/default.conf

server {
    listen 80 default_server;
    return 403;
    rewrite /(.*) /abc/$1;
}

# /usr/local/nginx/sbin/nginx -s reload

# curl -x127.0.0.1:80 e2rwejqw.com


403 Forbidden               #返回403
"white">
403 Forbidden
nginx

示例2:

server {
......
    if ( $request_uri ~ "\.htpasswd|\.bak" ) {
        return 405;
        rewrite /(.*) /aaa.txt;               #该行配置不会被执行    
    }
    
    #如果下面还有其他配置，会被执行
    ......
}

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    if ( $request_uri ~ "\.htpasswd|\.bak" ) {
        return 405;
        rewrite /(.*) /aaa.txt;                                   
    }
}

# /usr/local/nginx/sbin/nginx -s reload

# curl -x127.0.0.1:80 www.1.com/123/.htpasswd -I

HTTP/1.1 405 Not Allowed                #返回405
Server: nginx
Date: Mon, 11 Mar 2019 08:20:55 GMT
Content-Type: text/html
Content-Length: 166
Connection: keep-alive

返回字符串

示例3：

server {
    listen 80;
    server_name www.1.com;
    return 200 "hello";
}

如果想返回字符串，必须加上状态码，否则会报错。

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    if ( $request_uri ~ "\.htpasswd|\.bak" ) {
        return 200 "error";
        rewrite /(.*) /aaa.txt;                                   
    }
}

# /usr/local/nginx/sbin/nginx -s reload

# curl -x127.0.0.1:80 www.1.com/123/.htpasswd -I

HTTP/1.1 200 OK
Server: nginx
Date: Mon, 11 Mar 2019 08:26:58 GMT
Content-Type: application/octet-stream
Content-Length: 5
Connection: keep-alive

# curl -x127.0.0.1:80 www.1.com/123/.htpasswd
error

另外还可以支持JSON数据；支持写一个变量；支持html代码。

场景实战
背景：网站被黑，凡是在百度点击到本网站的请求，全部都跳转到一个赌博网站。

通过nginx解决：

server {
    if ( $http_referer ~ 'baidu.com' ) {
        return 200 "";
    }
}

如果写成：return http://$host$reauest_uri;，这在浏览器中会提示“重定向的次数过多”。

测试:

curl -x127.0.0.1:80 www.1.com/123/.htpasswd -I

HTTP/1.1 200 OK
Server: nginx
Date: Mon, 11 Mar 2019 08:54:17 GMT
Content-Type: application/octet-stream
Content-Length: 79
Connection: keep-alive

curl -x127.0.0.1:80 www.1.com/123/.htpasswd

返回url

示例4：

server {
    listen 80;
    server_name www.1.com;
    return http://www.baidu.com;        #注意：return后面的url必须是以http://或者https://开头的。
    rewrite /(.*) /abc/$1;              #该行配置不会被执行
}

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    if ( $request_uri ~ "\.htpasswd|\.bak" ) {
        return http://www.baidu.com;
        rewrite /(.*) /abc/$1;
    }
}

 /usr/local/nginx/sbin/nginx -s reload

 curl -x127.0.0.1:80 www.1.com/123/.htpasswd -I

HTTP/1.1 302 Moved Temporarily
Server: nginx
Date: Mon, 11 Mar 2019 08:44:07 GMT
Content-Type: text/html
Content-Length: 154
Connection: keep-alive
Location: http://www.baidu.com              #临时重定向到www.baidu.com

url前面也可以加状态码，但只能是301或302，如果是200，这url会变成字符串返回。

vim /usr/local/nginx/conf/vhost/www.1.com.conf

server {
    listen 80;
    server_name www.1.com;
    index index.html;
    root /data/wwwroot/www.1.com;

    rewrite_log on;

    if ( $request_uri ~ "\.htpasswd|\.bak" ) {
        return 200 http://www.baidu.com;
        rewrite /(.*) /abc/$1;
    }
}

# /usr/local/nginx/sbin/nginx -s reload

# curl -x127.0.0.1:80 www.1.com/123/.htpasswd -I

HTTP/1.1 200 OK
Server: nginx
Date: Mon, 11 Mar 2019 09:02:15 GMT
Content-Type: application/octet-stream
Content-Length: 20
Connection: keep-alive

# curl -x127.0.0.1:80 www.1.com/123/.htpasswd
http://www.baidu.com

Nginx 虚拟主机

2020-02-18T05:01:33.000Z

[TOC]

Nginx虚拟主机配置

同一台机器上可能跑多个站点，即多个域名。在生产环境下，我们通常会配置虚拟主机来满足需求。

Nginx默认虚拟主机

默认虚拟主机 就是不管什么域名解析到该服务器上，都会访问到默认虚拟主机。

前面讲过，nginx主配置文件 ==nginx.conf== 中每一个 ==server{}== 都是一个虚拟主机（站点）。一般情况下，如果没有指定，那么第一个 ==server{}== 就是默认虚拟主机的配置。

当然，我们还可以指定，可以在 ==server{==} 里面的 ==listen 80== 后面加上 ==default_server== ，这样就指明这个 ==server{}== 是默认虚拟主机。

1	linsten 80 default_server; #以80端口为例

通常为了规范，并不会在主配置文件下配置好多个 ==server{}== ，而是在 ==conf== 目录下面创建 ==vhost==目录，然后在 ==vhost== 目录下创建虚拟主机的配置文件，只需要在主配置文件中加上一行：

cat /nginx/conf/nginx.conf
user nobody;
worker_processes 8;

events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;


#    server {
#        listen       80;
#        server_name  localhost;
#        location / {
#            root   html;
#            index  index.html index.htm;
#        }
#        error_page   500 502 503 504  /50x.html;
#        location = /50x.html {
#            root   html;
#        }
#    }



include vhost/*.conf;   # 新增行

}

下面来简单测试一下：

创建两个server{}配置文件

mkdir -pv /data/wwwroot/www.1.com /data/wwwroot/www.2.com

echo "www.1.com" > /data/wwwroot/www.1.com/index.html

echo "www.2.com" > /data/wwwroot/www.2.com/index.html

mkdir /usr/local/nginx/conf/vhost

vim /usr/local/nginx/conf/vhost/www.1.com.conf          #写入下面内容
server {
    listen 80;
    server_name www.1.com;
    root /data/wwwroot/www.1.com;
}

vim /usr/local/nginx/conf/vhost/www.2.com.conf          #写入下面内容
server {
    listen 80;
    server_name www.2.com;
    root /data/wwwroot/www.2.com;
}

重载Nginx配置

/usr/local/nginx/sbin/nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

/usr/local/nginx/sbin/nginx -s reload

访问测试

curl -x127.0.0.1:80 www.1.com
www.1.com

curl -x127.0.0.1:80 www.2.com
www.2.com

curl -x127.0.0.1:80 www.3.com          #可以看出来，www.1.com是默认虚拟主机，虽然我们没有指定
www.1.com

一般情况下，我们需要指定默认虚拟主机，因为不指定就是排在第一个的 ==server{}== 是默认虚拟主机，这样有点不稳定。

指定默认虚拟主机

vim /usr/local/nginx/conf/vhost/default.conf             #写入下面内容
server {
    listen 80 default_server;                            #指定默认虚拟主机
    deny all;                                            #将非该服务器上的站点访问拒绝
}

访问测试

[root@LenovoBox ~] nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

[root@LenovoBox ~] nginx -s reload

[root@LenovoBox ~] curl -x127.0.0.1:80 www.3.com

403 Forbidden

403 Forbidden                   # 访问被拒绝
nginx/1.16.1

这样看起来就比较合理，服务器上没有的站点一律拒绝访问，而不是指向默认虚拟主机。

虚拟主机配置规范

一般规范来说，在主配置文件中 ==include== 虚拟主机配置文件，然后在 ==conf== 目录下创建 ==vhost== 目录，在 ==vhost==目录下定义虚拟主机配置，也就是 ==server{}== 配置部分。

上面在指定默认虚拟主机前的访问我们在 ==www.1.com.conf== 和 ==www.2.com.conf== 中没有指定index（索引页），它默认会访问 ==index.html== ，那如果指定的index不是 ==index.html== 呢？

指定index

cat www.1.com.conf 
server {
listen 80;
server_name www.1.com;
index 2.html;
root /data/wwwroot/www.1.com;
}

访问测试：

nginx -s reload

curl -x127.0.0.1:80 www.1.com

403 Forbidden

403 Forbidden             #提示403禁止访问，索引页有个特性：找不到会提示403，而不是404
nginx/1.16.1



echo "2.html" > /data/wwwroot/www.1.com/2.html

curl -x127.0.0.1:80 www.1.com   
2.html                                              #有了1.html之后就会默认访问到索引页

同时， ==server{}== 配置部分还支持域名泛解析，一个主域名下面可能会有很多个二级域名，这就会用到泛解析。

指定泛解析

cat graped.com.conf 
server {
listen 80;
server_name graped.com  *.graped.com;          # 连主域名一起访问到index，可以以空格分隔域名：
root /data/wwwroot/graped.com;
index index.html;
}

mkdir -pv /data/wwwroot/graped.com
echo "graped" > /data/wwwroot/graped.com/index.html

访问测试

curl -x127.0.0.1:80 graped.com
graped
curl -x127.0.0.1:80 1.graped.com
graped
curl -x127.0.0.1:80 2.graped.com
graped
curl -x127.0.0.1:80 sdfasdfasdklasdopweriqweorisdaf.graped.com
graped

基于不同端口的虚拟主机

虚拟主机不一定是监听80端口，只不过同一端口下的域名不能重复，不同端口下的域名是可以重复的。

定义同端口相同域名：

cat www.1.com.bak.conf 
server {
listen 80;
server_name www.1.com;
index index.html;
root /data/wwwroot/www.1.com.bak;
}

 cat www.1.com.conf 
server {
listen 80;
server_name www.1.com;
index 2.html;
root /data/wwwroot/www.1.com;
}

nginx -t 
nginx: [warn] conflicting server name "www.1.com" on 0.0.0.0:80, ignored    #会有报错提示，server name 冲突
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

定义不同端口相同域名：

cat www.1.com.conf 
server {
listen 80;
server_name www.1.com;
index 2.html;
root /data/wwwroot/www.1.com;
}

cat www.1.com.bak.conf 
server {
listen 8080;
server_name www.1.com;
index index.html;
root /data/wwwroot/www.1.com.bak;
}

mkdir -pv /data/wwwroot/www.1.com.bak

echo "www.1.com:8080" > /data/wwwroot/www.1.com.bak/index.html

访问测试

curl -x127.0.0.1:80 www.1.com
www.1.com

curl -x127.0.0.1:8080 www.1.com
www.1.com:8080

Nginx配置文件详解

2020-01-04T16:05:24.000Z

nginx.conf全局配置

user nobody;

定义运行nginx服务的用户,还可以加上组,如 user nobody nobody;

worker_processes 1;

定义nginx子进程数量，即提供服务的进程数量，该数值建议和服务cpu核数保持一致。
除了可以定义数字外，还可以定义为auto，表示让系统自动调整。

error_log logs/error.log;

定义错误日志的路径，可以是相对路径（相对prefix路径的），也可以是绝对路径。

该配置可以在此处定义，也可以定义到http、server、location里

error_log logs/error.log notice;

定义错误日志路径以及日志级别.

错误日志级别：常见的错误日志级别有[debug|info|notice|warn|error|crit|alert|emerg]，级别越高记录的信息越少。

如果不定义默认是error

pid logs/nginx.pid;

定义nginx进程pid文件所在路径，可以是相对路径，也可以是绝对路径。

worker_rlimit_nofile 100000;

定义nginx最多打开文件数限制。如果没设置的话，这个值为操作系统（ulimit -n）的限制保持一致。

把这个值设高，nginx就不会有“too many open files”问题了。

events配置部分

worker_connections 1024;

定义每个work_process同时开启的最大连接数，即允许最多只能有这么多连接。

accept_mutex on;

当某一个时刻只有一个网络连接请求服务器时，服务器上有多个睡眠的进程会被同时叫醒，这样会损耗一定的服务器性能。

Nginx中的accept_mutex设置为on，将会对多个Nginx进程（worker processer）接收连接时进行序列化，防止多个进程争抢资源。
默认就是on。

multi_accept on;

nginx worker processer可以做到同时接收多个新到达的网络连接，前提是把该参数设置为on。

默认为off，即每个worker process一次只能接收一个新到达的网络连接。

use epoll;

Nginx服务器提供了多个事件驱动器模型来处理网络消息。其支持的类型有：select、poll、kqueue、epoll、rtsing、/dev/poll以及eventport。

select：只能在Windows下使用，这个事件模型不建议在高负载的系统使用
poll:Nginx默认首选，但不是在所有系统下都可用
kqueue:这种方式在FreeBSD 4.1+, OpenBSD2.9+, NetBSD 2.0, 和 MacOS X系统中是最高效的
epoll: 这种方式是在Linux 2.6+内核中最高效的方式
rtsig:实时信号，可用在Linux 2.2.19的内核中，但不适用在高流量的系统中
/dev/poll: Solaris 7 11/99+,HP/UX 11.22+, IRIX 6.5.15+, and Tru64 UNIX 5.1A+操作系统最高效的方式
eventport: Solaris 10最高效的方式

http配置部分

官方文档 http://nginx.org/en/docs/
参考链接： https://segmentfault.com/a/1190000012672431
参考链接： https://segmentfault.com/a/1190000002797601
参考链接：http的header https://kb.cnblogs.com/page/92320/

MIME-Type

include mime.types; //cat conf/mime.types
定义nginx能识别的网络资源媒体类型（如，文本、html、js、css、流媒体等）

default_type application/octet-stream;

定义默认的type，如果不定义改行，默认为text/plain.

log_format

1
2
3

log_format main  '$remote_addr - $remote_user [$time_local] "$request" '
                  '$status $body_bytes_sent "$http_referer" '
                  '"$http_user_agent" "$http_x_forwarded_for"';

其中main为日志格式的名字，后面的为nginx的内部变量组成的一串字符串。

access_log logs/access.log main;

定义日志的路径以及采用的日志格式，该参数可以在server配置块中定义。

sendfile on;

是否调用sendfile函数传输文件，默认为off，使用sendfile函数传输，可以减少user mode和kernel mode的切换，从而提升服务器性能。
对于普通应用设为 on，如果用来进行下载等应用磁盘IO重负载应用，可设置为off，以平衡磁盘与网络I/O处理速度，降低系统的负载。

sendfile_max_chunk 128k;

该参数限定Nginx worker process每次调用sendfile()函数传输数据的最大值，默认值为0，如果设置为0则无限制。

tcp_nopush on;

当tcp_nopush设置为on时，会调用tcp_cork方法进行数据传输。
使用该方法会产生这样的效果：当应用程序产生数据时，内核不会立马封装包，而是当数据量积累到一定量时才会封装，然后传输。这样有助于解决网络堵塞问题。
默认值为on。举例：快递员收快递、发快递，包裹累积到一定量才会发，节省运输成本。

keepalive_timeout 65 60;

该参数有两个值，第一个值设置nginx服务器与客户端会话结束后仍旧保持连接的最长时间，单位是秒，默认为75s。
第二个值可以省略，它是针对客户端的浏览器来设置的，可以通过curl -I看到header信息中有一项Keep-Alive: timeout=60，如果不设置就没有这一项。
第二个数值设置后，浏览器就会根据这个数值决定何时主动关闭连接，Nginx服务器就不操心了。但有的浏览器并不认可该参数。

send_timeout

这个超时时间是发送响应的超时时间，即Nginx服务器向客户端发送了数据包，但客户端一直没有去接收这个数据包。
如果某个连接超过send_timeout定义的超时时间，那么Nginx将会关闭这个连接。

client_max_body_size 10m;

浏览器在发送含有较大HTTP包体的请求时，其头部会有一个Content-Length字段，client_max_body_size是用来限制Content-Length所示值的大小的。
这个限制包体的配置不用等Nginx接收完所有的HTTP包体，就可以告诉用户请求过大不被接受。会返回413状态码。
例如，用户试图上传一个1GB的文件，Nginx在收完包头后，发现Content-Length超过client_max_body_size定义的值，
就直接发送413(Request Entity Too Large)响应给客户端。

gzip on；

是否开启gzip压缩。

gzip_min_length 1k;

设置允许压缩的页面最小字节数，页面字节数从header头得content-length中进行获取。默认值是20。建议设置成大于1k的字节数，小于1k可能会越压越大。

gzip_buffers 4 16k;

设置系统获取几个单位的buffer用于存储gzip的压缩结果数据流。4 16k代表分配4个16k的buffer。

gzip_http_version 1.1;

用于识别 http 协议的版本，早期的浏览器不支持 Gzip 压缩，用户会看到乱码，所以为了支持前期版本加上了这个选项。
如果你用了Nginx反向代理并期望也启用Gzip压缩的话，由于末端通信是http/1.1，故请设置为 1.1。

gzip_comp_level 6;

gzip压缩比，1压缩比最小处理速度最快，9压缩比最大但处理速度最慢(传输快但比较消耗cpu)

gzip_types mime-type … ;

匹配mime类型进行压缩，无论是否指定,”text/html”类型总是会被压缩的。
在conf/mime.conf里查看对应的type。
示例：

text/plain application/x-javascript text/css text/html application/xml;```


gzip_proxied any;
> Nginx作为反向代理的时候启用，决定开启或者关闭后端服务器返回的结果是否压缩，匹配的前提是后端服务器必须要返回包含”Via”的 header头。
以下为可用的值：
off - 关闭所有的代理结果数据的压缩
expired - 启用压缩，如果header头中包含 "Expires" 头信息
no-cache - 启用压缩，如果header头中包含 "Cache-Control:no-cache" 头信息
no-store - 启用压缩，如果header头中包含 "Cache-Control:no-store" 头信息
private - 启用压缩，如果header头中包含 "Cache-Control:private" 头信息
no_last_modified - 启用压缩,如果header头中不包含 "Last-Modified" 头信息
no_etag - 启用压缩 ,如果header头中不包含 "ETag" 头信息
auth - 启用压缩 , 如果header头中包含 "Authorization" 头信息
any - 无条件启用压缩

gzip_vary on；
> 和http头有关系，会在响应头加个 Vary: Accept-Encoding ，可以让前端的缓存服务器缓存经过gzip压缩的页面，例如，用Squid缓存经过Nginx压缩的数据。

## nginx.conf server部分配置
> server{} 包含在http{}内部，每一个server{}都是一个虚拟主机（站点）。

##### 以下为nginx.conf配置文件中server{}部分的内容。

```bash
server {
    listen       80;  //监听端口为80，可以自定义其他端口，也可以加上IP地址，如，listen 127.0.0.1:8080;
    server_name  localhost; //定义网站域名，可以写多个，用空格分隔。
    #charset koi8-r; //定义网站的字符集，一般不设置，而是在网页代码中设置。
    #access_log  logs/host.access.log  main; //定义访问日志，可以针对每一个server（即每一个站点）设置它们自己的访问日志。

    ##在server{}里有很多location配置段
    location / {
        root   html;  //定义网站根目录，目录可以是相对路径也可以是绝对路径。
        index  index.html index.htm; //定义站点的默认页。
    }

    #error_page  404              /404.html;  //定义404页面

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;  //当状态码为500、502、503、504时，则访问50x.html
    location = /50x.html {
        root   html;  //定义50x.html所在路径
    }

    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #定义访问php脚本时，将会执行本location{}部分指令
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;  //proxy_pass后面指定要访问的url链接，用proxy_pass实现代理。
    #}

    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;  //定义FastCGI服务器监听端口与地址，支持两种形式，1 IP:Port， 2 unix:/path/to/sockt
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;  //定义SCRIPT_FILENAME变量，后面的路径/scripts为上面的root指定的目录
    #    include        fastcgi_params; //引用prefix/conf/fastcgi_params文件，该文件定义了fastcgi相关的变量
    #}

    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    # 
    #location ~ /\.ht {   //访问的url中，以/.ht开头的，如，www.example.com/.htaccess，会被拒绝，返回403状态码。
    #    deny  all;  //这里的all指的是所有的请求。
    #}
}


# another virtual host using mix of IP-, name-, and port-based configuration
#
#server {
#    listen       8000;  //监听8000端口
#    listen       somename:8080;  //指定ip:port
#    server_name  somename  alias  another.alias;  //指定多个server_name

#    location / {
#        root   html;
#        index  index.html index.htm;
#    }
#}


# HTTPS server
#
#server {
#    listen       443 ssl;  //监听443端口，即ssl
#    server_name  localhost;

### 以下为ssl相关配置
#    ssl_certificate      cert.pem;    //指定pem文件路径
#    ssl_certificate_key  cert.key;  //指定key文件路径

#    ssl_session_cache    shared:SSL:1m;  //指定session cache大小
#    ssl_session_timeout  5m;  //指定session超时时间
#    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;   //指定ssl协议
#    ssl_ciphers  HIGH:!aNULL:!MD5;  //指定ssl算法
#    ssl_prefer_server_ciphers  on;  //优先采取服务器算法
#    location / {
#        root   html;
#        index  index.html index.htm;
#    }
#}

python的安装和pycharm的使用

2018-11-19T03:36:58.000Z

环境安装

在windows 10上安装ptyhon 2.7.13和3.7.0

去网站 www.python.org/downloads
根据所需下载相对应版本，然后双击安装，一直保持默认即可。

备注: 在安装时候可以通过勾选添加系统环境变量来自动添加系统环境变量，如下图

安装好了输入python3和python会显示如图效果：

在Centos7.3上安装python2和python3

Centos7 默认自带python2.7

[root@GrapedLinux ~]# python
Python 2.7.5 (default, Nov  6 2016, 00:28:07) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

centos7.3安装python3.7.0 请跳转：centos安装python3

全部安装好后，在centos上也可以同时使用pyhton和python3

在Window 10上安装安装 PyCharm

去网站 www.jetbrains.com/pycharm 下载最新的pro版本pycharm
然后根据网上的教程进行激活操作，点击跳转参考资料

设置PyCharm 抬头

第一次使用的时候，我们可以通过File->setting->Editot->Code Style->File and Code Templates ->Python Script 来设置成如下的抬头

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : ${DATE} ${TIME}
# @Author  : Graped

第一个python例子

# -*- coding:utf-8 -*-
# @Time    : 2017/4/8 17:40
# @Author  : Graped
name = raw_input("print input your name: ")  # raw_input 此函数用来和用户进行参数交互
print("hello " + name)

Pycharm常用快捷键

Ctrl + c
Ctrl + x
Ctrl + v
Ctrl + d
Ctrl + shif + n
Ctrl + shif + f
Ctrl + 鼠标左键
Ctrl + alt + 方向左/右键注意和系统屏幕设置的快捷键冲突
Ctrl + a； ctrl + alt + l
Alt + enter
Ctrl + /
Tab shift +tab

如何去运行一个python程序

linux系统

1
2
3

chmod + x test.py
./test.py
python test.py

windows系统

cmd中：

1	python test.py

pycharm

直接点击运行

Pycharm的调试模式:

断点：就是程序执行到这个地方停下来
F7： Step Into 相当于eclipse的f5就是进入到代码
F8：Step Over 相当于eclipse的f6 跳到下一步
F9： resume programe 恢复程序或者执行到下一个断点

使用ansible-playbook推送安装nginx

2018-10-12T14:57:12.000Z

使用ansible-playbook推送安装nginx

本文主要介绍了如何将ansible-playbook投入生产中，下面我们以推送安装nginx举例

1. 思路：

现在主机上编译，配置好nginx，
然后将安装程序目录打包
最后用ansible分发下去

2. 流程图如下：

3. 执行配置过程

3.1 编译安装nginx详见：编译安装Nginx

3.2 创建ansible roles目录结构

1
2
3


cd /etc/ansible/
mkdir -pv nginx_install/rolse/{common,install}/{handlers,files,meta,tasks,templates,vars}

说明：
roles下有两个角色，common为一些准备操作，install为安装nginx的操作
每个角色下面又有6个目录，
handlers 下面是当发生改变时，要执行的操作，通常用在配置文件发生改变，重启服务等
flies 为安装时用到的一些文件
meta 为说明信息，说明角色依赖等信息
tasks 里面为核心配置文件
templates 通常存一些配置文件，启动脚本等模板文件
vars 下为定义的变量

3.3 将安装好的nginx程序包打包，并放到 `$/install/files/` 下面，启动脚本放入`$/install/templates`中，

1
2
3

cp /etc/init.d/nginx /root/nginx_install/rolse/install/templates/nginx
mv nginx.tar.gz /root/nginx_install/rolse/install/files/
cp nginx/conf/nginx.conf /root/nginx_install/rolse/install/templates/

3.4 在common目录下定义安装nginx的依赖包任务

cd common/tasks
vim main.yml

- name: install initaliztion require software
  #yum: name={{ items }} state=installed
  yum: name="pcre-devel,zlib-devel"
  #with_item
  #   - zlib-devel 
  #   - prce-devel

3.5 定义变量

cd install/vars/main.yml

nginx_user: www
nginx_port: 80
nginx_basedir: /usr/local/nginx

3.6 定义拷贝操作

vim  install/tasks/copy.yml

- name: Copy Nginx Software
  copy: src=nginx.tar.gz dest=/tmp/nginx.tar.gz owner=root group=root
- name: Uncommpreesion Nginx Software
  shell: tar -zxf /tmp/nginx.tar.gz -C /usr/local
- name: Copy Nginx Start Scrpit
  template: src=nginx dest=/etc/init.d/nginx owner=root group=root mode=0755
- name: Copy Nginx Config
  template: src=nginx.conf dest={{ nginx_basedir }}/conf/ owner=root group=root mode=0644

3.7 创建安装总线

vim install/tasks/install.yml 
 
- name: Creat Nginx User 
  user: name={{ nginx_user }} state=present createhome=no shell=/sbin/nologin
- name: Start Nginx Service 
  shell: /etc/init.d/nginx start
- name: Add Boot Start Nginx Service
  shell: chkconfig --level 345 nginx on
- name : Delete Nginx Commpression files
  shell: mv /tmp/nginx.tar.gz /tmp/old.tgz

3.8 创建执行总线

vim install/tasks/main.yml

- include: copy.yml
- include: install.yml

3.9 创建入口配置文件

vim install.yml---- hosts: nginxlabs  remote_user: root  gather_facts: True  roles:    - common    - install

Ansible详解

2018-10-08T03:45:12.000Z

[TOC]

一、Ansible介绍

不需要安装客户端，通过sshd去通信
基于模块工作，模块可以由任何语言开发
不仅支持命令行使用模块，也支持编写yaml格式的playbook，易于编写和阅读
安装十分简单，centos可直接yum安装
有提供UI（浏览器图形化）www.ansible.com/tower（收费）
ansible已经被redhat公司收购，它在github上是一款非常受欢迎的开源软件，Github地址：https://github.com/ansible/ansible
一本非常不错的入门电子书 https://ansible-book.gitbooks.io/ansible-first-book/

1.Ansible的安装配置

本次试验的环境

server1 GrapedLinux: CentOS 7.3 192.168.22.76
server2 Linux-Test1：CentOS 7.3 192.168.22.77
server3 Linux-Test2：CentOS 7.3 192.168.22.78

1.1 yum安装ansible

yum list | grep ansible
ansible.noarch                              2.4.2.0-2.el7              extras   
ansible-doc.noarch                          2.4.2.0-2.el7              extras   # 官方文档
# 可以看见自带的源里就有2.4版本的ansible

yum install -y  ansible*   # 安装ansible

2.配置ansible

2.1 在server1 上生成公钥

ssh-keygen  -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa): 
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
8e:a1:f5:d7:cf:fe:c2:d9:9b:f8:1e:4c:ac:2b:c2:7c root@GrapedLinux
The key's randomart image is:
+--[ RSA 2048]----+
|                 |
|                 |
|                 |
|              .  |
|      o S      o |
|     o =   .  +  |
|    . . = . .o = |
|         = E o* +|
|          o .+*Bo|
+-----------------+

2.2 ssh-copy-id命令来复制Ansible公钥到本机和server2节点中,server3节点不做处理。

复制到本机

ssh-copy-id -i ~/.ssh/id_rsa.pub root@127.0.0.1 
The authenticity of host '127.0.0.1 (127.0.0.1)' can't be established. 
ECDSA key fingerprint is 96:ed:84:e0:0f:c1:71:62:fc:c3:29:fd:31:ae:8c:98.
Are you sure you want to continue connecting (yes/no)? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
root@127.0.0.1's password: 

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'root@127.0.0.1'"
and check to make sure that only the key(s) you wanted were added.

复制到server1

ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.22.77# server1
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
root@192.168.22.77's password: 

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'root@192.168.22.77'"
and check to make sure that only the key(s) you wanted were added.

2.3 修改`vi /etc/ansible/hosts`

vim /etc/ansible/hosts
# 添加一下内容，其中Ansible-Test是组名
[Ansible-Test]
127.0.0.1
192.168.22.77

至此，Ansible的配置工作已经结束，下面我们来看看怎么使用Ansible

3. 使用Ansible远程执行命令

exp1 通过选择主机组的方式在远程机器上执行基础命令

exp2 通过IP/主机名的形式，在单独一台机器上执行基础命令

3.1 有时候会遇见如下图报错

这是由于server3的主机selinux没有关闭

解决办法是：

关闭selinux
安装libselinux-python

4. 使用Ansible 远程执行脚本

exp3 通过选择主机组的方式在远程机器上执行脚本

需要注意的是：

command 不支持带管道的命令，shell支持

5. 使用Ansible拷贝文件或者目录

5.1 拷贝目录

5.1.1其中各参数表示的意义是：

src表示源目录
dest表示目标目录
owner表示所属主
group表示所属组
mode表示权限

5.1.2 需要注意的是:

源目录会放到目标目录下面去，如果目标指定的目录不存在，它会自动创建。如果拷贝的是文件

5.2 拷贝文件

5.2.2 需要注意的是：

这里的/tmp/123和源机器上的/etc/passwd是一致的，但是如果目标机器上已经有了/tmp/123目录，则会在/tmp/123目录下面简历passwd文件

6. 使用ansible管理任务计划

6.1 在serverr1上创建任务管理计划

6.2 查看在server1上创建的任务计划

6.3 删除在server1上创建的计划任务

6.4 查看server1上创建的计划任务是否已经被删除

6.5 注意，通过Ansible创建的计划任务不可以手工更改，否则之后就没法再进行其他操作了

7. 使用ansible安装包和管理服务

7.1 使用ansible安装httpd服务

7.2 使用ansible卸载httpd服务

7.3 使用ansible启动httpd服务

Anbsible Playbook详解

Ansible playbook相当于把模块写入到配置文件里面，例如：

1. 编写配置文件

exp1:

vim /etc/ansible/labs.yml
---
- hosts: server1
- remote_user: root
- tasks:
        - name: labs
        - shell: echo `date` >> /tmp/time.txt

1.1配置文件说明

第一行需要有三个 -
hosts参数指定了对哪些主机进行操作，如果是多台机器，可以用逗号分开，也可以使用主机组，在/etc/ansibl/hosts里定义
user参数制定了使用什么用户登录远程主机操作;
tasks 指定了一个任务，其下面的name参数同样是对任务的描述，在执行过程中会打印出来，shell是ansible模块的名字

2. 执行nsible-playbook

1	ansible-play labs.yml

可以看到在server1上已经出现/tmp/time.txt

3. playbook里的变量

3.1 编写创建用户Ansible Playbook

exp2:

vim crean_user.yml

---
- name: crean_user
  hosts: server1
  user: root
  gather_facts: false  # 关闭facts
  vars: 
    - user: "test"  # 定义user变量
  tasks:
    - name: creat_user
      user: name="{{ user }}"  # 引用user变量，“{{user}}” 相当于shell脚本中$user

执行结果如下：

4. playbook中的循环

exp3:

vim while.yml 
---
- hosts: server1
  user: root
  tasks:
    - name: change mode for files
      file: path=/tmp/{{ item }} state=touch  mode=600  # 创建/tmp/{1,2,3}.txt 并富裕600权限
      with_items: # 循环对象
        - 1.txt
        - 2.txt
        - 3.txt

执行结果如下

执行效果如下：

5. playbook中的条件判断

exp4:

vim when.yml
---
- hosts: labs
  user: root
  gather_facts: true
  tasks:
      - name: use when
        shell: touch/tmp/when.txt;echo "`date`:the ip is real" >> /tmp/when.txt
        when: ansible_ens33.ipv4.address == "192.168.22.77"

执行结果如下：

执行效果如下：

6. playbook中的handers

handers 类似于shell中的 command1 && command2

exp5:

---
- name: handlers test
  hosts: server1
  user: root
  tasks:
    - name: copy file
      copy: src=/etc/passwd dest=/tmp/password
      notify: test handlers   
  handlers: # 上一步执行成功后，再执行下一步
    - name: test handlers
      shell: echo "copy finish" >> /tmp/password

执行结果如下：

执行效果如下：

修改Windows实例SID以搭建域环境

2018-10-07T10:24:09.000Z

[TOC]

修改Windows实例SID以搭建域环境

使用同一个Windows镜像创建的几台实例之间无法互相访问域或者无法同时加入域。

原因分析

使用同一个Windows镜像的几台实例，其SID（计算机安全标识符Security Identifier）是一样的。此时需要修改系统SID，以避免无法相互访问域，再进行域环境的搭建。

解决方法

Windows系统自带sysprep命令可以从已安装的Windows映像删除所有系统特定的信息，其中包括SID。脚本工具sysprep.ps1使用系统自带sysprep命令完成修改Windows SID。本文描述如何使用脚本工具sysprep.ps1修改系统SID。文档描述的内容适用于Windows Server 2008、Windows Server 2012和Windows Server 2016系统。

注意：
在修改系统SID前，建议您为系统盘创建快照，避免意外失败导致系统崩溃。
sysprep会将User Profile恢复为默认值，执行sysprep后会删除桌面上创建的文件。如果您希望执行脚本后自动删除，可以将文件放置在桌面上执行。

修改系统SID

按以下步骤修改系统SID。

远程连接Windows实例。
下载脚本工具 sysprep.ps1，存放在C盘。
启动CMD，运行命令 powershell。

注意：
如果您不是管理员用户，必须以管理员身份运行PowerShell。

运行命令 cd\ 切换路径到C盘根目录。
运行命令 .\Sysprep.ps1 -help 查看脚本说明。

查看脚本说明
参数说明：

参数	说明
-skiprearm	默认将Windows操作系统恢复到原始授权许可状态，如不需恢复，添加该参数。
-ReserveNetwork	运行脚本后保留经典网络实例的网络配置信息（IP、Subnet、Gateway、DNS），不会变动VPC网络类型ECS实例使用DHCP获取IP的配置。
-skippassword	使用默认密码
-ReserveHostname	保持主机名不变
-post_action	运行脚本后的后续操作。取值范围：shutdown,reboot,quit

运行命令 whoami /user 查看系统SID。
1
WhoAmIUser

运行命令

.\Sysprep.ps1 -ReserveHostname -ReserveNetwork -skiprearm -post_action "reboot" 
``` 


- 在弹窗中输入密码，并单击 确定，使实例自动重启。


![image2](https://s1.ax1x.com/2018/10/09/iJqVVP.png)

- [远程连接Windows实例。](https://help.aliyun.com/document_detail/25435.html?spm=a2c4g.11186623.2.14.21844abaGxsHT4)



运行命令 重新查看系统SID。
```powershell
whoami /user

注意事项

如果没有特定要求，运行以下命令时您需要修改密码。

1	powershell -executionpolicy bypass -file c:\sysprep.ps1 -ReserveHostname -ReserveNetwork -skiprearm -post_action "reboot"

bond绑定双网卡

2018-10-06T10:00:09.000Z

bond绑定双网卡

本文说明：为什么要做bond0 https://zhidao.baidu.com/question/294361679.html target=”_blank”>点击跳转

配置bond0

编辑配置文件

编辑虚拟网卡band0的配置文件ifcfg-bond0,加入以下内容：
示例如下:

#cat ifcfg-bond0     #需要我们手工创建
DEVICE=bond0
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=static
IPADDR=10.0.0.10
NETMASK=255.255.255.0
DNS2=4.4.4.4
GATEWAY=10.0.0.2
DNS1=10.0.0.2

编辑各个网卡的配置文件，这里用eth1和eth2。
ens32:

#cat ifcfg-ens32
DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes         #可以没有此字段，就需要开机执行ifenslave bond0 ens32 ens34命令了。
BONDING_OPTS="mode=0 miimon=100"

ens34:

#cat ifcfg-ens34
DEVICE=eth1
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes
BONDING_OPTS="mode=0 miimon=100"

系统加载bond

配置bonding驱动

1
2
3

#vi /etc/modprobe.d/bond.conf
alias bond0 binding
options bond0 miimon=100 mode=0

centos7默认没有加bonding内核模板，需要手工加载，加载方式
1
modprobe --first-time bonding

bond0验证

重启网卡后，可以使用

#cat /proc/net/bonding/bond0
Ethernet Channel Bonding Driver: v3.7.1 (April 27, 2011)

Bonding Mode: load balancing (round-robin)
MII Status: up
MII Polling Interval (ms): 0
Up Delay (ms): 0
Down Delay (ms): 0

Slave Interface: ens32
MII Status: up
Speed: 1000 Mbps
Duplex: full
Link Failure Count: 0
Permanent HW addr: 00:50:56:bf:55:22
Slave queue ID: 0

Slave Interface: ens34
MII Status: up
Speed: 1000 Mbps
Duplex: full
Link Failure Count: 0
Permanent HW addr: 00:50:56:bf:4a:64
Slave queue ID: 0

来查看bond的状态。如上图，即为绑定成功。

bond的七种模式

概览
目前网卡绑定mode共有七种(0~6)bond0、bond1、bond2、bond3、bond4、bond5、bond6

常用的有三种:

mode=0：平衡负载模式，有自动备援，但需要”Switch”支援及设定。
mode=1：自动备援模式，其中一条线若断线，其他线路将会自动备援。
mode=6：平衡负载模式，有自动备援，不必”Switch”支援及设定。

说明:
需要说明的是如果想做成mode 0的负载均衡,仅仅设置这里optionsbond0 miimon=100 mode=0是不够的,与网卡相连的交换机必须做特殊配置（这两个端口应该采取聚合方式），因为做bonding的这两块网卡是使用同一个MAC地址.从原理分析一下（bond运行在mode0下）：
mode 0下bond所绑定的网卡的IP都被修改成相同的mac地址，如果这些网卡都被接在同一个交换机，那么交换机的arp表里这个mac地址对应的端口就有多个，那么交换机接受到发往这个mac地址的包应该往哪个端口转发呢？正常情况下mac地址是全球唯一的，一个mac地址对应多个端口肯定使交换机迷惑了。所以 mode0下的bond如果连接到交换机，交换机这几个端口应该采取聚合方式（cisco称为 ethernetchannel，foundry称为portgroup），因为交换机做了聚合后，聚合下的几个端口也被捆绑成一个mac地址.我们的解决办法是，两个网卡接入不同的交换机即可。
mode6模式下无需配置交换机，因为做bonding的这两块网卡是使用不同的MAC地址。

七种bond模式说明：
第一种模式：mod=0 ，即：(balance-rr)Round-robin policy（平衡抡循环策略）
特点： 传输数据包顺序是依次传输（即：第1个包走eth0，下一个包就走eth1….一直循环下去，直到最后一个传输完毕），此模式提供负载平衡和容错能力；但是我们知道如果一个连接或者会话的数据包从不同的接口发出的话，中途再经过不同的链路，在客户端很有可能会出现数据包无序到达的问题，而无序到达的数据包需要重新要求被发送，这样网络的吞吐量就会下降

第二种模式：mod=1，即： (active-backup)Active-backup policy（主-备份策略）
特点： 只有一个设备处于活动状态，当一个宕掉另一个马上由备份转换为主设备。mac地址是外部可见得，从外面看来，bond的MAC地址是唯一的，以避免switch(交换机)发生混乱。此模式只提供了容错能力；由此可见此算法的优点是可以提供高网络连接的可用性，但是它的资源利用率较低，只有一个接口处于工作状态，在有 N 个网络接口的情况下，资源利用率为1/N

第三种模式：mod=2，即：(balance-xor)XOR policy（平衡策略）
特点： 基于指定的传输HASH策略传输数据包。缺省的策略是：(源MAC地址 XOR 目标MAC地址)% slave数量。其他的传输策略可以通过xmit_hash_policy选项指定，此模式提供负载平衡和容错能力

第四种模式：mod=3，即：broadcast（广播策略）
特点： 在每个slave接口上传输每个数据包，此模式提供了容错能力

第五种模式：mod=4，即：(802.3ad)IEEE 802.3ad Dynamic link aggregation（IEEE802.3ad 动态链接聚合）
特点： 创建一个聚合组，它们共享同样的速率和双工设定。根据802.3ad规范将多个slave工作在同一个激活的聚合体下。外出流量的slave选举是基于传输hash策略，该策略可以通过xmit_hash_policy选项从缺省的XOR策略改变到其他策略。需要注意的是，并不是所有的传输策略都是802.3ad适应的，尤其考虑到在802.3ad标准43.2.4章节提及的包乱序问题。不同的实现可能会有不同的适应性。

==必要条件==：

条件1：ethtool支持获取每个slave的速率和双工设定
条件2：switch(交换机)支持IEEE802.3ad Dynamic link aggregation
条件3：大多数switch(交换机)需要经过特定配置才能支持802.3ad模式

第六种模式：mod=5，即：(balance-tlb)Adaptive transmit load balancing（适配器传输负载均衡）
特点： 不需要任何特别的switch(交换机)支持的通道bonding。在每个slave上根据当前的负载（根据速度计算）分配外出流量。如果正在接受数据的slave出故障了，另一个slave接管失败的slave的MAC地址。
==该模式的必要条件：== ethtool支持获取每个slave的速率

第七种模式：mod=6，即：(balance-alb)Adaptive load balancing（适配器适应性负载均衡）
特点： 该模式包含了balance-tlb模式，同时加上针对IPV4流量的接收负载均衡(receiveload balance, rlb)，而且不需要任何switch(交换机)的支持。接收负载均衡是通过ARP协商实现的。bonding驱动截获本机发送的ARP应答，并把源硬件地址改写为bond中某个slave的唯一硬件地址，从而使得不同的对端使用不同的硬件地址进行通信。
来自服务器端的接收流量也会被均衡。当本机发送ARP请求时，bonding驱动把对端的IP信息从ARP包中复制并保存下来。当ARP应答从对端到达时，bonding驱动把它的硬件地址提取出来，并发起一个ARP应答给bond中的某个slave。使用ARP协商进行负载均衡的一个问题是：每次广播 ARP请求时都会使用bond的硬件地址，因此对端学习到这个硬件地址后，接收流量将会全部流向当前的slave。这个问题可以通过给所有的对端发送更新（ARP应答）来解决，应答中包含他们独一无二的硬件地址，从而导致流量重新分布。当新的slave加入到bond中时，或者某个未激活的slave重新激活时，接收流量也要重新分布。接收的负载被顺序地分布（roundrobin）在bond中最高速的slave上当某个链路被重新接上，或者一个新的slave加入到bond中，接收流量在所有当前激活的slave中全部重新分配，通过使用指定的MAC地址给每个 client发起ARP应答。下面介绍的updelay参数必须被设置为某个大于等于switch(交换机)转发延时的值，从而保证发往对端的ARP应答不会被switch(交换机)阻截。
==必要条件==：

条件1：ethtool支持获取每个slave的速率；
条件2：底层驱动支持设置某个设备的硬件地址，从而使得总是有个slave(curr_active_slave)使用bond的硬件地址，同时保证每个 bond 中的slave都有一个唯一的硬件地址。如果curr_active_slave出故障，它的硬件地址将会被新选出来的 curr_active_slave接管其实mod=6与mod=0的区别：mod=6，先把eth0流量占满，再占eth1，….ethX；而mod=0的话，会发现2个口的流量都很稳定，基本一样的带宽。而mod=6，会发现第一个口流量很高，第2个口只占了小部分流量

Galera：多主同步MySQL集群原理解析

2017-05-08T11:50:09.000Z

Galera Cluster 实现mysql群集

参考：
http://blog.itpub.net/14431099/viewspace-1316643/
http://lovestoned.blog.51cto.com/2904444/1617817
http://www.itbaofeng.com/?p=59
http://lansgg.blog.51cto.com/5675165/1180305
http://www.yunweipai.com/archives/19574.html

1. MySQL Galera介绍

MySQL/Galera是MySQL/InnoDB的多主集群,有以下特性:
同步复制
Active-active的多主拓扑结构
集群任意节点可以读和写
自动身份控制,失败节点自动脱离集群
自动节点接入
真正的基于”行”级别和ID检查的并行复制
客户端连接跟操作单台MySQL数据库的体验一致

总结下来，官网上给出了大概以上等数条优势，总结下来就是两个比较突出的点：多主和同步。
多主：
Galera Cluster没有MySQL主从集群只有一个主能提供写服务的限制，集群中每个节点都可读可写，无需读写分离。在一个Galera Cluster前直接部署HAProxy做读写负责均衡是比较常用的做法。
同步：
Galera replication具有实时性，能够保障不同节点的数据视图在较小的时间范围内是一致的。MySQL原生replication方案slave中的SQL线程和IO线程是分离的，即便使用半同步甚至同步复制，也可能因为SQL线程的速度跟不上IO线程而导致slave数据落后很多，当然5.7引入并行复制后会好很多，而Galera中除了具有并行复制的功能外，还具有flow control的功能来控制节点间数据同步的速度。

Galera本质是一个wsrep提供者（provider），运行依赖于wsrep的API接口。Wsrep API定义了一系列应用回调和复制调用库，来实现事务数据库同步写集(writeset)复制以及相似应用。目的在于从应用细节上实现抽象的，隔离的复制。虽然这个接口的主要目标是基于认证的多主复制，但同样适用于异步和同步的主从复制。

2. MySQL Galera安装

安装前准备

机器准备(虚拟机)

master 192.168.137.128
backup 192.168.137.129
joiner 192.168.137.130

安装依赖

确认安装有gcc和gcc-c++的版本最少为4.4

1	yum install -y gcc gcc-c++

确认安装有boost-devel的版本至少为1.4.1

1	yum install -y boost-devel

安装scons check-devel openssl-devel

1	yum install -y scons check-devel openssl-devel

MySQL Galera安装（从网上拷贝了一份安装文档，里面的版本为5.5.29，所以这里暂时用5.5.29版本）

安装含wsrep Patch的MySQL 5.5.29

yum install libaio
wget https://launchpad.net/codership-mysql/5.5/5.5.29-23.7.3/+download/mysql-5.5.29_wsrep_23.7.3-linux-x86_64.tar.gz
tar zxvf mysql-5.5.29_wsrep_23.7.3-linux-x86_64.tar.gz 
mv mysql-5.5.29_wsrep_23.7.3-linux-x86_64 /usr/local/mysql
cd /usr/local/mysql/
groupadd mysql
useradd -r -g mysql mysql
chown -R mysql:mysql .
./scripts/mysql_install_db --no-defaults --datadir=/usr/local/mysql/data --user=mysql
chown -R root .
chown -R mysql data

安装Galera复制插件

wget https://launchpad.net/galera/2.x/23.2.4/+download/galera-23.2.4-src.tar.gz
tar zxvf galera-23.2.4-src.tar.gz
cd galera-23.2.4-src
scons
cp garb/garbd /usr/local/mysql/bin/
cp libgalera_smm.so /usr/local/mysql/lib/plugin/

MySQL Galera配置

MySQL Galera配置例子:

 cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld
 mkdir -p /var/lib/mysql
 chown mysql:mysql /var/lib/mysql
 vi /etc/my.cnf
 cat /etc/my.cnf
 
 [client]
port = 3306
socket = /var/lib/mysql/mysql.sock

[mysqld_safe]
log-error = /var/lib/mysql/mysql.log
pid-file = /var/lib/mysql/mysql.pid

[mysqld]
wsrep_node_name = node1
wsrep_provider = /usr/local/mysql/lib/plugin/libgalera_smm.so
#wsrep_provider_options ='gcache.size=1G;socket.ssl_key=my_key;socket.ssl_cert=my_cert'
#wsrep_slave_threads=16
wsrep_sst_method = rsync
#wsrep_sst_auth=root:

port = 3306
socket = /var/lib/mysql/mysql.sock
user = mysql
basedir = /usr/local/mysql
datadir = /usr/local/mysql/data

default_storage_engine=InnoDB
#innodb_buffer_pool_size=1G
#innodb_log_file_size=256M
innodb_autoinc_lock_mode=2
innodb_locks_unsafe_for_binlog=1
innodb_flush_log_at_trx_commit=0
innodb_doublewrite=0
innodb_file_per_table=1

binlog_format=ROW
log-bin=mysql-bin
server-id=101
relay-log=mysql-relay-bin
#read_only=1
log-slave-updates=1

注：以上配置，参考与Mysql wsrep 参数

Mysql Galera启动与关闭

初次启动

/usr/local/mysql/bin/mysqld_safe --wsrep_cluster_address=gcomm:// >/dev/null &

# 或
service mysql start --wsrep_cluster_address=gcomm://

# ”gcomm://”是特殊的地址,仅仅是galera cluster初始化启动时候使用,再次启动的时候需要使用具体的IP地址.

启动完成后发现mysqld的监听端口有两个

1
2
3

[root@master ~]# netstat -plantu | grep mysqld
tcp        0      0 0.0.0.0:4567 0.0.0.0:*          LISTEN      3656/mysqld         
tcp        0      0 0.0.0.0:3306       0.0.0.0:*          LISTEN      3656/mysqld

这里4567端口是wsrep 使用的默认端口。

MySQL Galera新节点

节点接入
添加新节点的时候,新接入的节点叫Joiner,给joiner提供复制的节点叫Donor.新的节点接入需要:

安装带wsrep patch的MySQL版本
安装Galera复制插件
配置好新节点的MySQL(参考Donnor的my.cnf)
配置或启动的gcomm://的地址是需要使用donnor的IP.

接入节点backup：

1	/usr/local/mysql/bin/mysqld_safe --wsrep_cluster_address="gcomm://192.168.137.128:4567,192.168.137.130:4567" >/dev/null &

接入节点joiner:

1	service mysql start --wsrep_cluster_address="gcomm://192.168.137.128:4567,192.168.137.129:4567"

修改节点的wsrep_cluster_address
修改wsrep_cluster_address有两种方式:

i. 使用新的wsrep_cluster_address重启节点:

1	service mysql restart --wsrep_cluster_address="gcomm://192.168.137.129:4567,192.168.137.130:4567"

ii. 直接修改MySQL全局变量

mysql> SHOW VARIABLES LIKE 'wsrep_cluster_address';
+-----------------------+----------------------------+
| Variable_name         | Value                      |
+-----------------------+----------------------------+
| wsrep_cluster_address | gcomm://192.168.137.129:4567 |
+-----------------------+----------------------------+
1 row in set (0.00 sec)

mysql> set global wsrep_cluster_address="gcomm://192.168.137.129:4567,192.168.137.130:4567"; Query OK, 0 rows affected (2.20 sec)

mysql> SHOW VARIABLES LIKE 'wsrep_cluster_address';
+-----------------------+-------------------------------------------------------+
| Variable_name         | Value                                                 |
+-----------------------+-------------------------------------------------------+
| wsrep_cluster_address | gcomm://192.168.137.129:4567,192.168.137.130:4567 |
+-----------------------+-------------------------------------------------------+
1 row in set (0.00 sec)

MySQL Galera监控

查看相关变量

查看MySQL版本:

mysql> SHOW GLOBAL VARIABLES LIKE 'version';
+---------------+------------+
| Variable_name | Value      |
+---------------+------------+
| version       | 5.5.29-log |
+---------------+------------+
1 row in set (0.00 sec)

查看wsrep版本:

mysql> SHOW GLOBAL STATUS LIKE 'wsrep_provider_version';
+------------------------+------------+
| Variable_name          | Value      |
+------------------------+------------+
| wsrep_provider_version | 2.4(rXXXX) |
+------------------------+------------+
1 row in set (0.00 sec)

查看wsrep有关的所有变量:

mysql> SHOW VARIABLES LIKE 'wsrep%' \G
*************************** 1. row ***************************
Variable_name: wsrep_OSU_method
        Value: TOI
*************************** 2. row ***************************
Variable_name: wsrep_auto_increment_control
        Value: ON
*************************** 3. row ***************************
Variable_name: wsrep_causal_reads
        Value: OFF
*************************** 4. row ***************************
Variable_name: wsrep_certify_nonPK
        Value: ON
*************************** 5. row ***************************
Variable_name: wsrep_cluster_address
        Value: gcomm://192.168.1.222:4567,192.168.1.223:4567
*************************** 6. row ***************************
Variable_name: wsrep_cluster_name
        Value: my_wsrep_cluster
*************************** 7. row ***************************
Variable_name: wsrep_convert_LOCK_to_trx
        Value: OFF
*************************** 8. row ***************************
Variable_name: wsrep_data_home_dir
        Value: /usr/local/mysql/data/
*************************** 9. row ***************************
Variable_name: wsrep_dbug_option
        Value: 
*************************** 10. row ***************************
Variable_name: wsrep_debug
        Value: OFF
*************************** 11. row ***************************
Variable_name: wsrep_drupal_282555_workaround
        Value: OFF
*************************** 12. row ***************************
Variable_name: wsrep_forced_binlog_format
        Value: NONE
*************************** 13. row ***************************
Variable_name: wsrep_log_conflicts
        Value: OFF
*************************** 14. row ***************************
Variable_name: wsrep_max_ws_rows
        Value: 131072
*************************** 15. row ***************************
Variable_name: wsrep_max_ws_size
        Value: 1073741824
*************************** 16. row ***************************
Variable_name: wsrep_mysql_replication_bundle
        Value: 0
*************************** 17. row ***************************
Variable_name: wsrep_node_address
        Value: 
*************************** 18. row ***************************
Variable_name: wsrep_node_incoming_address
        Value: AUTO
*************************** 19. row ***************************
Variable_name: wsrep_node_name
        Value: node1
*************************** 20. row ***************************
Variable_name: wsrep_notify_cmd
        Value: 
*************************** 21. row ***************************
Variable_name: wsrep_on
        Value: ON
*************************** 22. row ***************************
Variable_name: wsrep_provider
        Value: /usr/local/mysql/lib/plugin/libgalera_smm.so
*************************** 23. row ***************************
Variable_name: wsrep_provider_options
        Value: base_host = 192.168.1.221; base_port = 4567; cert.log_conflicts = no; evs.causal_keepalive_period = PT1S; evs.debug_log_mask = 0x1; evs.inactive_check_period = PT0.5S; evs.inactive_timeout = PT15S; evs.info_log_mask = 0; evs.install_timeout = PT15S; evs.join_retrans_period = PT1S; evs.keepalive_period = PT1S; evs.max_install_timeouts = 1; evs.send_window = 4; evs.stats_report_period = PT1M; evs.suspect_timeout = PT5S; evs.use_aggregate = true; evs.user_send_window = 2; evs.version = 0; evs.view_forget_timeout = PT5M; gcache.dir = /usr/local/mysql/data/; gcache.keep_pages_size = 0; gcache.mem_size = 0; gcache.name = /usr/local/mysql/data//galera.cache; gcache.page_size = 128M; gcache.size = 128M; gcs.fc_debug = 0; gcs.fc_factor = 1; gcs.fc_limit = 16; gcs.fc_master_slave = NO; gcs.max_packet_size = 64500; gcs.max_throttle = 0.25; gcs.recv_q_hard_limit = 9223372036854775807; gcs.recv_q_soft_limit = 0.25; gcs.sync_donor = NO; gmcast.listen_addr = tcp://0.0.0.0:4567; gmcast.mcast_addr = ; gmcast.mcast_ttl = 1; gmcast.peer_timeout = PT3S; gmcast.time_wait = PT5S; gmcast.version = 0; ist.recv_addr = 192.168.1.221; pc.checksum = true; pc.ignore_quorum = false; pc.ignore_sb = false; pc.linger = PT20S; pc.npvo = false; pc.version = 0; pc.weight = 1; protonet.backend = asio; protonet.version = 0; replicator.causal_read_timeout = PT30S; replicator.commit_order = 3
*************************** 24. row ***************************
Variable_name: wsrep_recover
        Value: OFF
*************************** 25. row ***************************
Variable_name: wsrep_replicate_myisam
        Value: OFF
*************************** 26. row ***************************
Variable_name: wsrep_retry_autocommit
        Value: 1
*************************** 27. row ***************************
Variable_name: wsrep_slave_threads
        Value: 2
*************************** 28. row ***************************
Variable_name: wsrep_sst_auth
        Value: 
*************************** 29. row ***************************
Variable_name: wsrep_sst_donor
        Value: 
*************************** 30. row ***************************
Variable_name: wsrep_sst_donor_rejects_queries
        Value: OFF
*************************** 31. row ***************************
Variable_name: wsrep_sst_method
        Value: rsync
*************************** 32. row ***************************
Variable_name: wsrep_sst_receive_address
        Value: AUTO
*************************** 33. row ***************************
Variable_name: wsrep_start_position
        Value: 80cdd13d-8cf2-11e2-0800-e0817023b754:0
33 rows in set (0.00 sec)

状态监控
查看Galera集群状态:

mysql> show status like 'wsrep%';
+----------------------------+----------------------------------------------------------+
| Variable_name              | Value                                                    |
+----------------------------+----------------------------------------------------------+
| wsrep_local_state_uuid     | 80cdd13d-8cf2-11e2-0800-e0817023b754                     |
| wsrep_protocol_version     | 4                                                        |
| wsrep_last_committed       | 3 |
| wsrep_replicated           | 3                                                        |
| wsrep_replicated_bytes     | 522                                                      |
| wsrep_received             | 6  |
| wsrep_received_bytes       | 1134  |
| wsrep_local_commits        | 1                                                        |
| wsrep_local_cert_failures  | 0                                                        |
| wsrep_local_bf_aborts      | 0                                                        |
| wsrep_local_replays        | 0                                                        |
| wsrep_local_send_queue     | 0                                                        |
| wsrep_local_send_queue_avg | 0.000000                                                 |
| wsrep_local_recv_queue     | 0                                                        |
| wsrep_local_recv_queue_avg | 0.000000                                                 |
| wsrep_flow_control_paused  | 0.000000                                                 |
| wsrep_flow_control_sent    | 0                                                        |
| wsrep_flow_control_recv    | 0                                                        |
| wsrep_cert_deps_distance   | 1.000000                                                 |
| wsrep_apply_oooe           | 0.000000                                                 |
| wsrep_apply_oool           | 0.000000                                                 |
| wsrep_apply_window         | 1.000000                                                 |
| wsrep_commit_oooe          | 0.000000                                                 |
| wsrep_commit_oool          | 0.000000                                                 |
| wsrep_commit_window        | 1.000000                                                 |
| wsrep_local_state          | 4                                                        |
| wsrep_local_state_comment  | Synced                                                   |
| wsrep_cert_index_size      | 5                                                        |
| wsrep_causal_reads         | 0                                                        |
| wsrep_incoming_addresses   | 192.168.1.221:3306,192.168.1.222:3306,192.168.1.223:3306 |
| wsrep_cluster_conf_id      | 13                                                       |
| wsrep_cluster_size         | 3                                                        |
| wsrep_cluster_state_uuid   | 80cdd13d-8cf2-11e2-0800-e0817023b754                     |
| wsrep_cluster_status       | Primary                                                  |
| wsrep_connected            | ON                                                       |
| wsrep_local_index          | 0                                                        |
| wsrep_provider_name        | Galera                                                   |
| wsrep_provider_vendor      | Codership Oy                         |
| wsrep_provider_version     | 2.4(rXXXX)                                               |
| wsrep_ready                | ON |
+----------------------------+----------------------------------------------------------+
40 rows in set (0.00 sec)

监控状态说明

集群完整性检查:

wsrep_cluster_state_uuid:在集群所有节点的值应该是相同的,有不同值的节点,说明其没有连接入集群.wsrep_cluster_conf_id:正常情况下所有节点上该值是一样的.如果值不同,说明该节点被临时”分区”了.当节点之间网络连接恢复的时候应该会恢复一样的值.wsrep_cluster_size:如果这个值跟预期的节点数一致,则所有的集群节点已经连接.wsrep_cluster_status:集群组成的状态.如果不为”Primary”,说明出现”分区”或是”split-brain”状况.

节点状态检查:

wsrep_ready: 该值为ON,则说明可以接受SQL负载.如果为Off,则需要检查wsrep_connected.wsrep_connected: 如果该值为Off,且wsrep_ready的值也为Off,则说明该节点没有连接到集群.(可能是wsrep_cluster_address或wsrep_cluster_name等配置错造成的.具体错误需要查看错误日志)wsrep_local_state_comment:如果wsrep_connected为On,但wsrep_ready为OFF,则可以从该项查看原因.

复制健康检查:

wsrep_flow_control_paused:表示复制停止了多长时间.即表明集群因为Slave延迟而慢的程度.值为0~1,越靠近0越好,值为1表示复制完全停止.可优化wsrep_slave_threads的值来改善.wsrep_cert_deps_distance:有多少事务可以并行应用处理.wsrep_slave_threads设置的值不应该高出该值太多.wsrep_flow_control_sent:表示该节点已经停止复制了多少次.wsrep_local_recv_queue_avg:表示slave事务队列的平均长度.slave瓶颈的预兆.最慢的节点的wsrep_flow_control_sent和wsrep_local_recv_queue_avg这两个值最高.这两个值较低的话,相对更好.

检测慢网络问题:

wsrep_local_send_queue_avg:网络瓶颈的预兆.如果这个值比较高的话,可能存在网络瓶

冲突或死锁的数目:

wsrep_last_committed:最后提交的事务数目wsrep_local_cert_failures和wsrep_local_bf_aborts:回滚,检测到的冲突数目

docker详解

2017-04-13T16:23:46.000Z

容器虚拟化–docker

核心概念

镜像
是一个只读的模板，类似于安装系统用到的那个iso文件，我们通过镜像来完成各种应用的部署。
docker容器
镜像类似于操作系统，而容器类似于虚拟机本身。它可以被启动、开始、停止、删除等操作，每个容器都是相互隔离的。
docker仓库
存放镜像的一个场所，仓库分为公开仓库和私有仓库。最大的公开仓库是hub.docker.com，国内公开仓库http://dockerpool.com/

安装

centos6(6.5之前版本需要升级一下 yum update )

1 2	yum install -y epel-release yum install -y docker-io

centos7

1	yum install -y docker

启动docker

1	/etc/init.d/docker start

镜像管理

docker pull  centos   //从docker.com获取centos镜像，如果太慢，直接做个加速http://www.apelearn.com/bbs/thread-15126-1-1.html
docker images  //查看本地都有哪些镜像
docker tag centos graped123  //为centos镜像设置标签为graped123，再使用docker images查看会多出来一行，改行的image id和centos的一样
docker search (image-name)   //从docker仓库搜索docker镜像，后面是关键词
docker run -t -i centos  /bin/bash  //用下载到的镜像开启容器，-i表示让容器的标准输入打开，-t表示分配一个伪终端，要把-i -t 放到镜像名字前面
当该镜像发生修改后，我们可以把该镜像提交重新生成一个新版本进行在本地。
docker ps  //查看运行的容器
docker rmi centos  //用来删除指定镜像， 其中后面的参数可以是tag，如果是tag时，实际上是删除该tag，只要该镜像还有其他tag，就不会删除该镜像。当后面的参数为镜像ID时，则会彻底删除整个镜像，连通所有标签一同删除
docker ps -a //查看所有容器，包括已经退出的。

创建镜像-基于已有镜像的容器创建
运行docker run后，进入到该容器中

1	docker exec -it f68 /bin/bash

我们做一些变更，比如安装一些东西，然后针对这个容器进行创建新的镜像

1
2
3

docker commit -m "change somth"  -a "somebody info"  image_id 
#例如：
ocker commit -m "install httpd" -a "Graped" 2c74d574293f graped/centos

这个命令有点像svn的提交，-m 加一些改动信息，-a 指定作者相关信息 2c74d这一串为容器id，再后面为新镜像的名字。

创建镜像-基于本地模板导入
模块获取，可以直接在网上下载一个模块 http://openvz.org/Download/templates/precreated 可惜速度并不快，假如我们下载了一个centos的模板 centos-5-x86.tar.gz 那么导入该镜像的命令为：

1	cat centos-6-x86_64-minimal.tar.gz \|docker import - centos-6-x86_64

把现有镜像，导出为一个文件：

1	docker save -o centos_with_net.tar graped/centos

我们还可以用该文件恢复本地镜像：

1 2	docker load --input centos_net.tar #或者 docker load < centos_net.tar

上传镜像

1	docker push image_name

MySQL调优

2017-04-07T12:15:18.000Z

MySQL调优可以从几个方面来做：

架构层：
做从库，实现读写分离；

系统层次：
增加内存；
给磁盘做raid0或者raid5以增加磁盘的读写速度；RAID相关
可以重新挂载磁盘，并加上noatime参数，这样可以减少磁盘的i/o;

MySQL本身调优：
(1) 如果未配置主从同步，可以把bin-log功能关闭，减少磁盘i/o
(2) 在my.cnf中加上skip-name-resolve,这样可以避免由于解析主机名延迟造成mysql执行慢
(3) 调整几个关键的buffer和cache。调整的依据，主要根据数据库的状态来调试。如何调优可以参考5.

应用层次：
查看慢查询日志，根据慢查询日志优化程序中的SQL语句，比如增加索引

调整几个关键的buffer和cache

1) key_buffer_size 首先可以根据系统的内存大小设定它，大概的一个参考值：1G以下内存设定128M；2G/256M; 4G/384M;8G/1024M；16G/2048M.这个值可以通过检查状态值Key_read_requests和 Key_reads,可以知道key_buffer_size设置是否合理。比例key_reads / key_read_requests应该尽可能的低，至少是1:100，1:1000更好(上述状态值可以使用SHOW STATUS LIKE ‘key_read%’获得)。注意：该参数值设置的过大反而会是服务器整体效率降低!

2) table_open_cache 打开一个表的时候，会临时把表里面的数据放到这部分内存中，一般设置成1024就够了，它的大小我们可以通过这样的方法来衡量：如果你发现 open_tables等于table_cache，并且opened_tables在不断增长，那么你就需要增加table_cache的值了(上述状态值可以使用SHOW STATUS LIKE ‘Open%tables’获得)。注意，不能盲目地把table_cache设置成很大的值。如果设置得太高，可能会造成文件描述符不足，从而造成性能不稳定或者连接失败。

3) sort_buffer_size 查询排序时所能使用的缓冲区大小,该参数对应的分配内存是每连接独占!如果有100个连接，那么实际分配的总共排序缓冲区大小为100 × 4 = 400MB。所以，对于内存在4GB左右的服务器推荐设置为4-8M。

4) read_buffer_size 读查询操作所能使用的缓冲区大小。和sort_buffer_size一样，该参数对应的分配内存也是每连接独享!

5) join_buffer_size 联合查询操作所能使用的缓冲区大小，和sort_buffer_size一样，该参数对应的分配内存也是每连接独享!

6) myisam_sort_buffer_size 这个缓冲区主要用于修复表过程中排序索引使用的内存或者是建立索引时排序索引用到的内存大小，一般4G内存给64M即可。

7) query_cache_size MySQL查询操作缓冲区的大小，通过以下做法调整：SHOW STATUS LIKE ‘Qcache%’; 如果Qcache_lowmem_prunes该参数记录有多少条查询因为内存不足而被移除出查询缓存。通过这个值，用户可以适当的调整缓存大小。如果该值非常大，则表明经常出现缓冲不够的情况，需要增加缓存大小;Qcache_free_memory:查询缓存的内存大小，通过这个参数可以很清晰的知道当前系统的查询内存是否够用，是多了，还是不够用，我们可以根据实际情况做出调整。一般情况下4G内存设置64M足够了。

8) thread_cache_size 表示可以重新利用保存在缓存中线程的数，参考如下值：1G —> 8 2G —> 16 3G —> 32 >3G —> 64
除此之外，还有几个比较关键的参数：

9) thread_concurrency 这个值设置为cpu核数的2倍即可

10) wait_timeout 表示空闲的连接超时时间，默认是28800s，这个参数是和interactive_timeout一起使用的，也就是说要想让wait_timeout 生效，必须同时设置interactive_timeout，建议他们两个都设置为10

11) max_connect_errors 是一个MySQL中与安全有关的计数器值，它负责阻止过多尝试失败的客户端以防止暴力破解密码的情况。与性能并无太大关系。为了避免一些错误我们一般都设置比较大，比如说10000

12) max_connections 最大的连接数，根据业务请求量适当调整，设置500足够

13) max_user_connections 是指同一个账号能够同时连接到mysql服务的最大连接数。设置为0表示不限制。通常我们设置为100足够

Hadoop伪分布式安装

2017-04-05T15:46:19.000Z

Hadoop内容
官网：http://hadoop.apache.org/#What+Is+Apache+Hadoop%3F

Hadoop内容较复杂，安装根据不同的需求有三种模式
独立模式（standalong/local model ）：无需任何守护进程，所有程序都单个的JVM上执行。本模式适用于开发阶段下的测试和调式MapReduce。
伪分布（pesudo-distributed model）：Hadoop守护进程都运行在本地服务器上，模拟一个小规模的集群
全分布(full distributed model)：Hadoop 守护进程运行在一个集群上。

先安装伪分布式进行结合测试

1. 安装前准备：

JDK1.6.X
SSH
RSYNC

2. 下载hadoop文件之后解压到目录,直接解压后设定为Hadoop目录即可

在环境变量中添加JAVA目录与Hadoop目录

PATH=$PATH:$HOME/bin
#export PATH
export JAVA_HOME=/usr/local/java/jdk1.6.0_30
export PATH=$JAVA_HOME/bin:/usr/local/mysql/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
unset USERNAME
export HADOOP_INSTALL=/usr/local/hadoop
export PATH=$PATH:$HADOOP_INSTALL/bin

执行hadoop version 查看hadoop版本，且查看是否运行

[root@test /] hadoop version
Hadoop 1.2.1
Subversion https://svn.apache.org/repos/asf/hadoop/common/branches/branch-1.2 -r 1503152
Compiled by mattf on Mon Jul 22 15:23:09 PDT 2013
From source with checksum 6923c86528809c4e7e6f493b6b413a9a
This command was run using /usr/local/hadoop/hadoop-core-1.2.1.jar

3. 配置SSH

首先要能ssh登录到本机

1	ssh localhost

如果无法登录，执行

1 2	[root@zabbix hadoop] ssh-keygen -t dsa -P '' -f ~/.ssh/id_sea [root@zabbix hadoop] cat ~/.ssh/id_dsa.pub >>~/.ssh/authorized_keys

4. 格式化HDFS文件系统

使用Hadoop前，必须格式化一个全新的HDFS系统，创建一个空的文件系统。

1	hadoop namenode -frmat

5. Hadoop配置文件

conf目录中
core-site.xml 配置Common组件
hdfs-site.xml 配置HDFS属性
mapred-site.xml 配置MapReduce属性
默认情况下，三种模式的默认配置如图

修改配置文件

/core-site.xml
fs.default.namehdfs://localhost/
//hdfs-site.xml
dfs.replication1
//mapred-site.xml
mapred.job.trackerlocalhost:8021

6. 启动HDFS和MapReduce守护进程

[root@test conf] start-dfs.sh
starting namenode, logging to /usr/local/hadoop/libexec/../logs/hadoop-root-namenode-zabbix.out
localhost: starting datanode, logging to /usr/local/hadoop/libexec/../logs/hadoop-root-datanode-zabbix.out
localhost: starting secondarynamenode, logging to /usr/local/hadoop/libexec/../logs/hadoop-root-secondarynamenode-zabbix.out
[root@test conf]  start-mapred.sh
starting jobtracker, logging to /usr/local/hadoop/libexec/../logs/hadoop-root-jobtracker-zabbix.out
localhost: starting tasktracker, logging to /usr/local/hadoop/libexec/../logs/hadoop-root-tasktracker-zabbix.out

7. 查看进程是否启动

http://namenode:50030/jobtracker.jsp
http://namenode:50070/dfshealth.jsp
[root@test conf]# netstat -lnp |grep 50030
tcp        0      0 :::50030                    :::*                        LISTEN      3071/java           
[root@test conf]# netstat -lnp |grep 50070
tcp        0      0 :::50070               :::*                        LISTEN      2676/java

JAVA的jps查看

jps
3220 TaskTracker
2676 NameNode
3071 JobTracker
2803 DataNode
2962 SecondaryNameNode
3503 Jps

Hadoop常用命令

//查看HDFS文件列表
hadoop fs -ls /usr/local/log/
//创建文件目录
hadoop fs -mkdir /usr/local/log/test
//删除文件
/hadoop fs -rm /usr/local/log/11
//上传一个本机文件到HDFS中/usr/local/log/目录下
adoop fs -put /usr/local/src/infobright-4.0.6-0-x86_64-ice.rpm  /usr/local/log/
//下载
hadoop fs –get /usr/local/log/infobright-4.0.6-0-x86_64-ice.rpm   /usr/local/src/
//查看文件
hadoop fs -cat /usr/local/log/20131008_10/access.log.zabbix
//查看HDFS基本使用情况
[root@hh ~] hadoop dfsadmin -report
Configured Capacity: 10397683712 (9.68 GB)
Present Capacity: 9388027904 (8.74 GB)
DFS Remaining: 9324613632 (8.68 GB)
DFS Used: 63414272 (60.48 MB)                                 
DFS Used%: 0.68%
Under replicated blocks: 1
Blocks with corrupt replicas: 0
Missing blocks: 1
-------------------------------------------------
Datanodes available: 1 (1 total, 0 dead)
Name: 127.0.0.1:50010
Decommission Status : Normal
Configured Capacity: 10397683712 (9.68 GB)
DFS Used: 63414272 (60.48 MB)
Non DFS Used: 1009655808 (962.88 MB)
DFS Remaining: 9324613632(8.68 GB)
DFS Used%: 0.61%
DFS Remaining%: 89.68%
Last contact: Tue Oct 08 13:41:05 CST 2013

rsync 自动安装脚本

2017-04-05T07:15:36.000Z

rsync 自动安装脚本

#!/bin/bash#home_page http://grapedlinux.cnrpm -q rsync &>/dev/null;rpm -q xinetd &>/dev/null || yum install rsync xinetd --nogpgcheck -y &>/dev/nullt=$(echo $?)if [[ "$t" != 0 ]];then    echo "rsync is not install,try to install is faild,please check you yum configure or network! "    exit 5fised -i 's/yes/no/' /etc/xinetd.d/rsync cat > /etc/rsyncd.conf < /etc/server.pass </dev/nullres=$(netstat -nutlp | grep 873 | grep -v grep | wc -l)if [[ $res -ne 1 ]];then    echo "Something wrong! please check."ficat <



Redis详解
2017-04-04T15:35:45.000Z
一、Redis介绍
redis是一个key-value存储系统，官方站点http://redis.io
和memcached类似，但支持数据持久化
支持更多value类型，除了和string外，还支持hash、lists(链表）、sets(集合）和sorted sets（有序集合）集中数据类型
redis使用了两种文件格式：全量数据(RDB)和增量请求(aof)。全量数据格式是把内存中的数据写入磁盘，便于下次读取文件进行加载。增量请求文件则是把内存中的数据序列化为操作请求，用于读取文件进行replay得到数据
redis的存储分为内存存储、磁盘存储和log文件三部分
二、Redis下载安装
下载解压：
1
2
3
4
cd /usr/local/src
wget   https://codeload.github.com/antirez/redis/tar.gz/2.8.21
mv 2.8.21 redis-2.8.21.tar.gz
tar xf redis-2.8.21.tar.gz
安装：
1
2
3
4
5
cd redis-2.8.21
yum install -y gcc gcc-c++
make

cd src && make PREFIX=/usr/local/redis install
三、Redis配置
配置Redis的配置文件
1
2
mkdir /usr/local/redis/etc
vim  /usr/local/redis/etc/redis.conf
加入如下内容：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
daemonize yes
pidfile /usr/local/redis/var/redis.pid
port 6379
timeout 300
loglevel debug
logfile /usr/local/redis/var/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis/var/
appendonly no
appendfsync always
下面是redis.conf的主 要配置参数的意义：
daemonize：是否以后台daemon方式运行
pidfile：pid文件位置
port：监听的端口号
timeout：请求超时时间
loglevel：log信息级别
logfile：log文件位置
databases：开启数据库的数量
save x x ：保存快照的频率，第一个x表示多长时间，第三个x表示执行多少次写操作。在一定时间内执行一定数量的写操作时，自动保存快照。可设置多个条件。
rdbcompression：是否使用压缩
dbfilename：数据快照文件名（只是文件名，不包括目录）
dir：数据快照的保存目录（这个是目录）
appendonly：是否开启appendonlylog，开启的话每次写操作会记一条log，这会提高数据抗风险能力，但影响效率。
appendfsync：appendonlylog如何同步到磁盘（三个选项，分别是每次写都强制调用fsync、每秒启用一次fsync、不调用fsync等待系统自己同步）
编写一个redis启动脚本
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
vi /etc/init.d/redis   //加入如下内容：
#!/bin/sh
#
# redis        init file for starting up the redis daemon
#
# chkconfig:   - 20 80
# description: Starts and stops the redis daemon.

# Source function library.
. /etc/rc.d/init.d/functions

name="redis-server"
basedir="/usr/local/redis"
exec="$basedir/bin/$name"
pidfile="$basedir/var/redis.pid"
REDIS_CONFIG="$basedir/etc/redis.conf"

[ -e /etc/sysconfig/redis ] && . /etc/sysconfig/redis

lockfile=/var/lock/subsys/redis

start() {
    [ -f $REDIS_CONFIG ] || exit 6
    [ -x $exec ] || exit 5
    echo -n $"Starting $name: "
    daemon --user ${REDIS_USER-redis} "$exec $REDIS_CONFIG"
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $name: "
    killproc -p $pidfile $name
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {
    stop
    start
}

reload() {
    false
}

rh_status() {
    status -p $pidfile $name
}

rh_status_q() {
    rh_status >/dev/null 2>&1
}


case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
        restart
        ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart}"
        exit 2
esac
exit $?
因为脚本启动时以redis用户启动的，所以需要增加redis用户
1
2
3
4
5
6
7
useradd -s /sbin/nologin redis
mkdir /usr/local/redis/var
chmod 777 /usr/local/redis/var
chmod 755 /etc/init.d/redis
chkconfig  --add redis
chkconfig redis on
service redis start
四、Redis数据类型
string：是最简单的类型，你可以理解成Memcached一样的类型，一个key对应一个value，支持的操作与Memcached的操作类似，它的功能更丰富。设置可以存二进制的对象。
1
2
3
4
5
6
7
8
/usr/local/redis/bin/redis-cli 

127.0.0.1:6379> mset key1 szk key2 love key3 yc
OK
127.0.0.1:6379> mget key1 key2 key3
1) "szk"
2) "love"
3) "yc"
 list:是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等。操作中key理解为链接的名字。使用List结构，我们可以轻松的实现最新消息排行等功能。使用List结构，我们可以轻松地实现最新消息排行等功能。List的另一个应用就是消息队列，可以利用list的push操作，将任务存在list中，然后工作线程再用pop操作将任务取出进行执行。
1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> lpush list1 123
(integer) 1
127.0.0.1:6379> lpush list1 aaa
(integer) 2
127.0.0.1:6379> lpush list1 "123 456"
(integer) 3
127.0.0.1:6379> rpop list1
"123"
127.0.0.1:6379> rpop list1
"aaa"
127.0.0.1:6379> rpop list1
set:是集合，和我们数学中的集合概念类似，对集合的操作有添加删除元素，有对多个集合求交并差等操作。操作中key理解为集合的名字。比如在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。因为Redis非常人性化的为几个提供了求交集、并集、差集等操作，那么就可以非常方便的实现如共同关注、共同喜好、二度好友等功能，对上面的所有集合 操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。QQ有一个社交功能叫做”好友标签”，这时就可以使用redis的集合来实现，把每一个用户的标签都存储在一个集合之中。
1
2
3
4
5
6
127.0.0.1:6379> sadd set1 zbc
(integer) 1
127.0.0.1:6379> sadd set1 szk
(integer) 1
127.0.0.1:6379> smembers set1
1) "zbc"
sorted set:是有序集合，它比set多了一个权重参数score，使得集合中的元素能够按score进行有序排列，比如一个存储全班同学成绩的Sorted Sets，其集合value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然的排序。
1
2
3
4
5
6
7
8
9
10
127.0.0.1:6379> zadd mset2 2 "cde 123"
(integer) 1
127.0.0.1:6379> zadd mset2 4 "a123a"
(integer) 1
127.0.0.1:6379> zadd mset2 24 "123-aaa"
(integer) 1
127.0.0.1:6379> zrange mset2 0 -1
1) "cde 123"
2) "a123a"
3) "123-aaa"
 hash：在memcached中，经常将一些结构化的信息打包成hashmap，在客户端序列化后存储为一个字符串的值（一般是JSON格式），比如用户的昵称、年龄、性别、积分等。
六、Redis通用配置
daemonize no #默认情况下，redis并不是以daemon形式来运行的。通过daemonize配置项可以控制redis的运行形式。
pidfile /path/to/redis.pid #当以daemon形式运行时，redis会生成一个pid文件，默认会生成在/var/run/redis.pid
bind 192.168.1.200 #指定绑定的IP，可以有多个
port 6379 #指定监听端口
unixsocket /tmp/redis.sock #也可以监听socket
unixsocketperm 755 #当监听socket时可以指定权限为755
timeout 0 #当一个redis-client一直没有请求发向server端，那么server端有权主动关闭这个连接，可以通过timeout来设置“空间超时时限”,0表示永不关闭
tcp-keepalive 0 #TCP连接保活策略，可以通过tcp-keepalive配置项来进行设置，单位为秒，假如设置为60秒，则server端会每60秒向连接空闲的客户端发起一次ACk请求，以检查客户端是否已经挂掉，对于无响应的客户端则会关闭其连接。如果设置为0，则不会进行保活检测
loglevel notice #日志级别，有四种debug，verbose，notice，warning
logfile “” #定义日志路径
syslog-ident redis #如果希望日志打印到sysllog中，通过syslog-enabled来控制
syslog-facility local0 #指定syslog的设备，可以是USER或者local0-local7
databases 16 #设置数据库的总数量，select n 选择数据库，0 - 15
七、Redis快照配置（rdb持久化）
save 900 1 #表示每15分钟且至少有1个key改变，就触发一次持久化
save 300 10 #表示每5分钟至少有10个key改变，就触发一次持久化
save 60 1000 #表示每60秒至少有10000个key改变，就触发一次持久
save “” #这样可以禁用rdb持久化
stop-write-on-bgsave-error yes #rdb持久化写入磁盘避免不了会出现失败的情况，默认一旦出现失败，redis会马上停止写操作。如果你觉得无所谓，那就可以使用选项关闭这个功能
rdbcompression yes #是否要压缩
rdbchecksum yes #是否进行数据校验
dir ./ #定义快照文件储存路径
八、Redis安全相关配置
1
2
3
4
vim /usr/local/redis/etc/redis.conf  #设置redis-server的密码
#增加下面配置

requirepass szk
1
/usr/local/redis/bin/redis-cli -a szk  #-a指定密码登录
rename-command CONFIG szk.config   #将CONFIG命令更名为szk.config，这样可以避免误操作，但 如果使用了AOF持久化，建议不要启用该功能
rename-command CONFIG “”  #也可以后面定义为空，这样就禁掉了该CONFIG命令
九、Redis限制相关配置
maxclients 10000 #限制最大客户端连接数
maxmemory  #设定最大内存使用数，单位是byte
maxmemory-policy volatile-lru #指定内存移除规则
maxmemory-samples 3 #LRU算大和最小TTL算法都并非是精确的算法，而是估算值。所以你可以设置样本的大小。假如redis默认会检查三个key，并选择其中LRU的那个，那么你可以改变这个key样本的数量。
十、Redis AOF持久化相关配置
appendonly no #如果是yes，则开启aof持久化
appendfilename “appendonly.aof” #指定aof文件名字，保存在dir参数指定的命令
appendfsync everysec #指定fsync()调用模式，有三种no(不调用fsync)，always（每次写都会调用fsync)，exerysec(每秒钟调用一次fsync)。第一种最快，第二种数据最安全，但性能会差一些，默认为第三种方案，性能和安全兼顾。
no-appendfsync-on-rewrite no #使用no可避免当写入量非常大时的磁盘IO阻塞
auto-aof-rewrite-percentage 10 #规定什么情况下触发aof重写。该值为一个比例，10表示当aof文件增幅达到10%时则会触发重写机制
auto-aof-rewrite-min-size 64mb #重写会有一个条件，就是不能低于64MB
十一、Redis慢日志相关配置
针对慢日志，你可以设置两个参数，一个是执行时长，单位是微秒，另一个是慢日志的长度。当一个新的命令被写入日志时，最老的一条会从命令日志队列中被移除。
slowlog-log-slower-than 10000 #慢于10000ms则记录日志
slowlog-max-len 128 #日志长度
十二、Redis主从配置
分别按照之前介绍的步骤安装好redis并启动
master 配置文件不用动
slave配置文件上加一行:slaveof 192.168.1.200 6379
masterauth szk  #如果主上设置了密码，要加这行
分别启动master和slave1
2
3
4
5
6
7
8
9
10
tail /usr/local/redis/var/redis.log 

3966] 18 Feb 15:02:58.330 * MASTER <-> SLAVE sync: receiving 192 bytes from master
[3966] 18 Feb 15:02:58.330 * MASTER <-> SLAVE sync: Flushing old data
[3966] 18 Feb 15:02:58.330 * MASTER <-> SLAVE sync: Loading DB in memory
[3966] 18 Feb 15:02:58.330 * MASTER <-> SLAVE sync: Finished with success
[3966] 18 Feb 15:03:03.344 - DB 0: 7 keys (0 volatile) in 8 slots HT.
[3966] 18 Feb 15:03:03.344 - 1 clients connected (0 slaves), 466840 bytes in use
[3966] 18 Feb 15:03:08.396 - DB 0: 7 keys (0 volatile) in 8 slots HT.
[3966] 18 Feb 15:03:08.397 - 1 clients connected (0 slaves), 466848 bytes in use
测试：
1
2
3
4
5
6
/usr/local/redis/bin/redis-cli -a szk      #主

127.0.0.1:6379> set key1 szk
OK
127.0.0.1:6379> get key1            
"szk"
1
2
3
4
5
6
/usr/local/redis/bin/redis-cli             #从

127.0.0.1:6379> get key1
"szk"

OK
十三、Redis主从其他相关配置
slave-read-only yes #让从只读
repl-ping-slave-period 10  #设置slave向master发起ping的频率，每10s发起一次
repl-timeout 60  #设置slave ping不同master多少s后就超时
repl-disable-tcp-nodelay no  #是否开启tcp_nodeay，开启后将会使用更少的带宽，但会有延迟，所以建议关闭
repl-backlog-size 1mb  #同步队列的长度，backuplog是master的一个缓冲区，主从断开后，master会先把数据写到缓冲区，slave再次连接会从缓冲区中同步数据
repl-backlog-ttl 3600  #主从断开后，缓冲区的有效期，默认1小时
slave-priority 100  #多个slave是可以设置优先级的，数值越小优先级越高，应用于集群中，支持slave切换为mster，优先级最高的才会切换
min-slave-to-write 3 #和下面的一起使用，它的意思是master发现有超过3个slave的延迟高于10s，那么master就会暂时停止写操作。这两个数值任何一个为0，则关闭该功能，默认第一数值是0
min-slaves-max-log 10 
十四、string常用操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
127.0.0.1:6379> set key1 szk  #给key1赋值为szk
OK 
127.0.0.1:6379> get key1    #获取这个值value
"szk"
127.0.0.1:6379> set key1 yc  #一个key对应一个value，多次赋值，会覆盖前面的value
OK
127.0.0.1:6379> get key1  
"yc"


127.0.0.1:6379> setex key3 10 1   #用来给key设定过期时间,ttl key3查看时间
OK

127.0.0.1:6379> mset key1 1 key2 2 key3 3    #同时设置多个key
OK
127.0.0.1:6379> mget key1 key2 key3    
1) "1"
2) "2"
3) "3"
十五、Hash常用操作
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
127.0.0.1:6379> hset hash1 name szk
(integer) 1
127.0.0.1:6379> hset hash1  age 23
(integer) 1
127.0.0.1:6379> hset hash1  job it
(integer) 1
127.0.0.1:6379> hgetall hash1 
1) "name"
2) "szk"
3) "age"
4) "23"
5) "job"
6) "it"

127.0.0.1:6379> hmset hash2 name yc age 24 job teacher    #批量创建
OK
127.0.0.1:6379> hgetall hash2
1) "name"
2) "yc"
3) "age"
4) "24"
5) "job"
6) "teacher"

127.0.0.1:6379> hdel hash2 job     #删除某个值
(integer) 1
127.0.0.1:6379> hgetall hash2
1) "name"
2) "yc"
3) "age"
4) "24"

127.0.0.1:6379> hkeys hash2   #查看所有的key
1) "name"
2) "age"

127.0.0.1:6379> hvals hash2   #查看所有的values
1) "yc"
2) "24"

127.0.0.1:6379> hlen hash2    #查看hash有几个filed
(integer) 2
十六、list常用操作
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
127.0.0.1:6379> lpush list1 a    #从左边插入

(integer) 3
127.0.0.1:6379> lpush list1 b     #从左边插入
(integer) 4
127.0.0.1:6379> lpush list1 c      #从左边插入
(integer) 5
127.0.0.1:6379> lrange list1 0 -1       #从左边往右罗列，最先插入在最后边
1) "c"
2) "b"
3) "a"

127.0.0.1:6379> lpop list1          #从最左边取出
"c"
127.0.0.1:6379> lrange list1 0 -1    #从左边往右罗列
1) "b"
2) "a"


127.0.0.1:6379> rpush list1 1          #从右边插入
(integer) 5
127.0.0.1:6379> rpush list1 2           #从右边插入
(integer) 6
127.0.0.1:6379> rpush list1 3           #从右边插入
(integer) 7
127.0.0.1:6379> lrange list1 0 -1       #从右往左罗列，最后插入在最后边
1) "b"
2) "a"
3) "1"
4) "2"
5) "3"

127.0.0.1:6379> linsert list1  before 3  5        #在3前面插入一个5
(integer) 8
127.0.0.1:6379> lrange list1 0 -1
1) "b"
2) "a"
3) "1"
4) "2"
5) "5"
6) "3"


127.0.0.1:6379> lset list1 7 6             #将0开始的第7个元素换成6
OK
127.0.0.1:6379> lrange list1 0 -1
1) "b"
2) "a"
3) "456"
4) "123"
5) "1"
6) "2"
7) "5"
8) "6"


127.0.0.1:6379> lindex list1 7     #查看从0开始的第7个元素
"6"


127.0.0.1:6379> llen list1          #查看列表中有几个元素
(integer) 8
十七、set数据常用操作 
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
127.0.0.1:6379> sadd set1 1        #向集合set1中放入元素
(integer) 1
127.0.0.1:6379> sadd set1 2
(integer) 1
127.0.0.1:6379> sadd set1 3
(integer) 1
127.0.0.1:6379> sadd set1 4
(integer) 1
127.0.0.1:6379> smembers set1    #查看集合中所有元素
1) "zbc"
2) "1"
3) "szk"
4) "2"
5) "3"
6) "4"
127.0.0.1:6379> spop set1     #随机取出一个元素，删除
"szk"

127.0.0.1:6379> sdiff set1 seta       #比较差集，以set1为主来比较
1) "zbc"
2) "4"

127.0.0.1:6379> sdiffstore set3  seta set1   #比较差集，将结果存入set3中
(integer) 2
127.0.0.1:6379> SMEMBERS set3    #tab自动补全，但显示为大写
1) "2"
2) "szk"
十八、zset常用操作
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
127.0.0.1:6379> zadd zset1 1 abc     #创建有序集合
(integer) 1
127.0.0.1:6379> zadd zset1 10 aabc   #创建有序集合
(integer) 1
127.0.0.1:6379> zadd zset1 5 aaa    #创建有序集合
(integer) 1
127.0.0.1:6379> zadd zset1 88 bbb   #创建有序集合
(integer) 1
127.0.0.1:6379> zadd zset1 888 szk   #创建有序集合
(integer) 1
127.0.0.1:6379> ZRANGE zset1 0 -1   #显示所有元素，按顺序显示
1) "abc"
2) "aaa"
3) "aabc"
4) "bbb"
5) "szk"
127.0.0.1:6379> ZRANGE zset1 0 -1 withscores    #可以带上分值
1) "abc"
2) "1"
3) "aaa"
4) "5"
5) "aabc"
6) "10"
7) "bbb"
8) "88"
9) "szk"
10) "888"

127.0.0.1:6379> ZREM zset1 abc       #删除指定元素
(integer) 1
127.0.0.1:6379> ZRANGE zset1 0 -1 withscores
1) "aaa"
2) "5"
3) "aabc"
4) "10"
5) "bbb"
6) "88"
7) "szk"
8) "888"

127.0.0.1:6379> zrevrank zset1 szk  #返回元素的索引值，索引值从0开始，按score正向排序
(integer) 0
127.0.0.1:6379> zrank zset1 szk     #同上，不同的是，按score反序排序
(integer) 3

127.0.0.1:6379> ZCARD  zset1   #查看集合元素的个数
(integer) 4 
127.0.0.1:6379> zcount zset1 1 20   #查看分值区间内的元素个数
(integer) 2

127.0.0.1:6379> zrangebyscore zset1 1 100 withscores   #返回分支范围在1-100的元素
1) "aaa"
2) "5"
3) "aabc"
4) "10"
5) "bbb"
6) "88"
127.0.0.1:6379> zrangebyscore zset1 0 10    #删除分支范围在0-10的元素，按score排序
1) "aaa"
2) "aabc"
十九、键值和服务器命令
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
127.0.0.1:6379> keys *            #列出所有键值
1) "key3"
2) "seta"
3) "hash1"
4) "list1"
5) "key2"
6) "zset1"
7) "mset2"
8) "set2"
9) "set1"
10) "key1"
11) "hash2"
12) "set3"
127.0.0.1:6379> keys key*
1) "key3"
2) "key2"
3) "key1"

127.0.0.1:6379> EXISTS list1      #查看是否有list1
(integer) 1
127.0.0.1:6379> del key1      #删除key1
(integer) 1
127.0.0.1:6379> EXISTS key1
(integer) 0

127.0.0.1:6379> EXPIRE key3 10     #设置过期时间
(integer) 1
127.0.0.1:6379> get key3
"3"
127.0.0.1:6379> ttl key3    #查看key的过期时间，-1不存在过期  -2不存储键值
(integer) -2
127.0.0.1:6379> EXists key3 
(integer) 0

127.0.0.1:6379> select 0     #切换库，默认16个库
OK
127.0.0.1:6379> select 1
OK

127.0.0.1:6379[1]> set key1 111   #新建一个键值
OK
127.0.0.1:6379[1]> keys *
1) "key1"
127.0.0.1:6379[1]> move set1 2    #移动到库2
(integer) 0
127.0.0.1:6379[1]> select 2     #切换库2
OK
127.0.0.1:6379[2]> keys *    
1) "key1"


127.0.0.1:6379[2]> EXPIRE key1 200    #设置过期时间
(integer) 1
127.0.0.1:6379[2]> ttl key1
(integer) 193
127.0.0.1:6379[2]> PERSIST key1     #取消过期时间
(integer) 1
127.0.0.1:6379[2]> ttl key1
(integer) -1
127.0.0.1:6379[2]> RANDOMKEY    #随机返回一个key
"key1"

127.0.0.1:6379[2]> RENAME key1 szk   #更改一个key的名字
OK
127.0.0.1:6379[2]> keys *
1) "szk"
127.0.0.1:6379[2]> type szk         #查看一个键值的类型
string
二十、服务相关的操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
127.0.0.1:6379[2]> DBSIZE    #查看一个库的键值数
(integer) 1
127.0.0.1:6379[2]> select 0
OK
127.0.0.1:6379> DBSIZE 
(integer) 10

127.0.0.1:6379> info   #查看redis服务信息
# Server
redis_version:2.8.21
redis_git_sha1:00000000
略

127.0.0.1:6379> flushdb    #清空当前数据库中所有的键
OK
127.0.0.1:6379> keys *
(empty list or set)

127.0.0.1:6379> flushall   #清空所有数据库中的所有的key
OK
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> keys *
(empty list or set)
二十一、PHP中应用Redis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
cd /usr/local/src
wget  http://pecl.php.net/get/redis-2.2.5.tgz
tar xf redis-2.2.5.tgz
cd redis-2.2.5
/usr/local/php/bin/phpize
./configure --with-php-config=/usr/local/php/bin/php-confi
make ; make install
mv /usr/local/php/lib/php/extensions/no-debug-zts-20100525/redis.so /usr/lib64/

vim /usr/local/php/php.ini

extension_dir = /usr/lib64/
extension = redis.so

usr/local/php/bin/php -m | grep redis
redis
加载成功，可以重启 nginx 看看 phpinfo 页
二十二、Redis实现session共享
php.ini中加入
session.save_handler = “redis”
session.save_path = “tcp://127.0.0.1:6379”
或者apache虚拟主机加入
php_value session.save_handler “redis”
php_value session.save_path “tcp://127.0.0.1:6379”
或者php-fpm.conf对应的pool中加入
php_value[session.save_handler] = redis
php_value[session.save_path] = “ tcp://127.0.0.1:6379 “


nginx+tomcat 配置负载均衡集群
2017-04-04T02:38:51.000Z
一、Hello world
1、前期环境准备
准备两个解压版tomcat，如何同时启动两个tomcat，方法如下：
首先去apache tomcat官网下载一个tomcat解压版。
解压该压缩包，生成n份tomcat 分别命名为 tomcat1，tomcat2，

然后修改server.xml配置文件，分别进入tomcat/conf/目录，修改server.xml，一共三处。

第一处：

第二处、tomcat访问端口号：

第三处：

之后修改bin下的启动文件
分别进入tomcat/bin目录，修改 startup.bat
在文件第一行添加如下配置（添加时删除#注释，在startup.bat文件中rem代表注释）：在文件第一行添加如下配置（添加时删除#注释，在startup.bat文件中rem代表注释）：1
2
3
4
5
6
7
# tomcat名称
set TITLE="tomcat1"
# tomcat启动路径
set CATALINA_BASE="D:\tools\tomcat1"
set CATALINA_HOME="D:\tools\tomcat1"
# JDK所在路径，如果环境变量已经配置，则可忽略，前提是你所有tomcat要共用一个jdk。另外如果设置，此处路径不能有空格
SET JAVA_HOME="D:\Java\jdk1.7.0_45"
如图：


启动tomcat
平常直接双击startup.bat即可，但是为了查看配置信息，可以在cmd中启动，如下图：

访问tomcat
在浏览器地址栏输入：http://localhost:8081 和 http://localhost:8082
nginx官网下载解压版nginx。
创建一个简单的web项目。为了直观的区分访问的哪个tomcat，在页面写上标记8081、8082。
分别部署到对应的tomcat下。如图：2、配置nginx
进入nginx-1.10.1\conf路径，修改配置文件nginx.conf。
配置服务器组，在http{}节点之间添加upstream配置。（注意不要写localhost，不然访问速度会很慢）
1
2
3
4
upstream nginxDemo {
    server 127.0.0.1:8081;   #服务器地址1
    server 127.0.0.1:8082;   #服务器地址2
}
修改nginx监听的端口号80，改为8080。
1
2
3
4
server {
    listen       8080;
    ......
}
在location{}中，利用proxy_pass配置反向代理地址；此处“http://”不能少，后面的地址要和第一步upstream定义的名称保持一致。
1
2
3
4
5
location / {
        root   html;
        index  index.html index.htm;
        proxy_pass http://nginxDemo; #配置方向代理地址
    }
如下图：
3、启动nginx和tomcat，访问
我是Windows系统，所以直接在nginx-1.10.1目录下双击nginx.exe即可。可在任务管理器中查看：

最后在浏览器输入地址：http://localhost:8080/nginxDemo/index.jsp，每次访问就会轮流访问tomcat了（如果F5刷新不管用，建议试试鼠标指针放到地址栏，点击Enter键）。


到这里，一个非常简单的负载均衡就配置完成了。


Nginx主要应用场景
2017-04-03T03:23:42.000Z
前言
本文只针对Nginx在不加载第三方模块的情况能处理哪些事情，由于第三方模块太多所以也介绍不完，当然本文本身也可能介绍的不完整，毕竟只是我个人使用过和了解到过得。所以还请见谅，同时欢迎留言交流。
Nginx能做什么
1. 反向代理
2. 负载均衡
3. HTTP服务器（包含动静分离）
4. 正向代理
以上就是我了解到的Nginx在不依赖第三方模块能处理的事情，下面详细说明每种功能怎么做。
反向代理
反向代理应该是Nginx做的最多的一件事了，什么是反向代理呢，以下是百度百科的说法：反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。简单来说就是真实的服务器不能直接被外部网络访问，所以需要一台代理服务器，而代理服务器能被外部网络访问的同时又跟真实服务器在同一个网络环境，当然也可能是同一台服务器，端口不同而已。 下面贴上一段简单的实现反向代理的代码。
1
2
3
4
5
6
7
8
9
10
server {  
        listen       80;                                                         
        server_name  localhost;                                               
        client_max_body_size 1024M;

        location / {
            proxy_pass http://localhost:8080;
            proxy_set_header Host $host:$server_port;
        }
    }
保存配置文件后启动Nginx，这样当我们访问localhost的时候，就相当于访问localhost:8080了。
负载均衡
负载均衡也是Nginx常用的一个功能，负载均衡其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。简单而言就是当有2台或以上服务器时，根据规则随机的将请求分发到指定的服务器上处理，负载均衡配置一般都需要同时配置反向代理，通过反向代理跳转到负载均衡。而Nginx目前支持自带3种负载均衡策略，还有2种常用的第三方策略。
1、RR（默认）
每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。
简单配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
upstream test {
     server localhost:8080;
     server localhost:8081;
 }
 server {
     listen       81;                                                         
     server_name  localhost;                                               
     client_max_body_size 1024M;

     location / {
         proxy_pass http://test;
         proxy_set_header Host $host:$server_port;
     }
 }
负载均衡的核心代码为
1
2
3
4
upstream test {
    server localhost:8080;
    server localhost:8081;
}
这里我配置了2台服务器，当然实际上是一台，只是端口不一样而已，而8081的服务器是不存啊在的,也就是说访问不到，但是我们访问http://localhost 的时候,也不会有问题，会默认跳转到http://localhost:8080 具体是因为Nginx会自动判断服务器的状态，如果服务器处于不能访问（服务器挂了），就不会跳转到这台服务器，所以也避免了一台服务器挂了影响使用的情况，由于Nginx默认是RR策略，所以我们不需要其他更多的设置。
2、权重
指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。 例如
1
2
3
4
upstream test {
    server localhost:8080 weight=9;
    server localhost:8081 weight=1;
}
那么10次一般只会有1次会访问到8081，而有9次会访问到8080
3、ip_hash
上面的2种方式都有一个问题，那就是下一个请求来的时候请求可能分发到另外一个服务器，当我们的程序不是无状态的时候（采用了session保存数据），这时候就有一个很大的很问题了，比如把登录信息保存到了session中，那么跳转到另外一台服务器的时候就需要重新登录了，所以很多时候我们需要一个客户只访问一个服务器，那么就需要用iphash了，iphash的每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。
1
2
3
4
5
upstream test {
    ip_hash;
    server localhost:8080;
    server localhost:8081;
}
4、fair（第三方）
按后端服务器的响应时间来分配请求，响应时间短的优先分配。
1
2
3
4
5
upstream backend { 
    fair; 
    server localhost:8080;
    server localhost:8081;
}
5、url_hash（第三方）
按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。 在upstream中加入hash语句，server语句中不能写入weight等其他的参数，hash_method是使用的hash算法
1
2
3
4
5
6
upstream backend { 
    hash $request_uri; 
    hash_method crc32; 
    server localhost:8080;
    server localhost:8081;
}
以上5种负载均衡各自适用不同情况下使用，所以可以根据实际情况选择使用哪种策略模式,不过fair和url_hash需要安装第三方模块才能使用，由于本文主要介绍Nginx能做的事情，所以Nginx安装第三方模块不会再本文介绍
HTTP服务器
Nginx本身也是一个静态资源的服务器，当只有静态资源的时候，就可以使用Nginx来做服务器，同时现在也很流行动静分离，就可以通过Nginx来实现，首先看看Nginx做静态资源服务器
1
2
3
4
5
6
7
8
9
10
11
server {
       listen       80;                                                         
       server_name  localhost;                                               
       client_max_body_size 1024M;


       location / {
              root   e:\wwwroot;
              index  index.html;
          }
   }
这样如果访问http://localhost 就会默认访问到E盘wwwroot目录下面的index.html，如果一个网站只是静态页面的话，那么就可以通过这种方式来实现部署。
动静分离
动静分离是让动态网站里的动态网页根据一定规则把不变的资源和经常变的资源区分开来，动静资源做好了拆分以后，我们就可以根据静态资源的特点将其做缓存操作，这就是网站静态化处理的核心思路
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
upstream test{  
       server localhost:8080;  
       server localhost:8081;  
    }   

    server {  
        listen       80;  
        server_name  localhost;  

        location / {  
            root   e:\wwwroot;  
            index  index.html;  
        }  

        # 所有静态请求都由nginx处理，存放目录为html  
        location ~ \.(gif|jpg|jpeg|png|bmp|swf|css|js)$ {  
            root    e:\wwwroot;  
        }  

        # 所有动态请求都转发给tomcat处理  
        location ~ \.(jsp|do)$ {  
            proxy_pass  http://test;  
        }  

        error_page   500 502 503 504  /50x.html;  
        location = /50x.html {  
            root   e:\wwwroot;  
        }  
    }
这样我们就可以吧HTML以及图片和css以及js放到wwwroot目录下，而tomcat只负责处理jsp和请求，例如当我们后缀为gif的时候，Nginx默认会从wwwroot获取到当前请求的动态图文件返回，当然这里的静态文件跟Nginx是同一台服务器，我们也可以在另外一台服务器，然后通过反向代理和负载均衡配置过去就好了，只要搞清楚了最基本的流程，很多配置就很简单了，另外localtion后面其实是一个正则表达式，所以非常灵活
正向代理
正向代理，意思是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。客户端才能使用正向代理。当你需要把你的服务器作为代理服务器的时候，可以用Nginx来实现正向代理，但是目前Nginx有一个问题，那么就是不支持HTTPS，虽然我百度到过配置HTTPS的正向代理，但是到最后发现还是代理不了，当然可能是我配置的不对，所以也希望有知道正确方法的同志们留言说明一下。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
resolver 114.114.114.114 8.8.8.8;
server {

    resolver_timeout 5s;

    listen 81;

    access_log  e:\wwwroot\proxy.access.log;
    error_log   e:\wwwroot\proxy.error.log;

    location / {
        proxy_pass http://$host$request_uri;
    }
}
resolver是配置正向代理的DNS服务器，listen 是正向代理的端口，配置好了就可以在ie上面或者其他代理插件上面使用服务器ip+端口号进行代理了。
补充
Nginx是支持热启动的，也就是说当我们修改配置文件后，不用关闭Nginx，就可以实现让配置生效，当然我并不知道多少人知道这个，反正我一开始并不知道，导致经常杀死了Nginx线程再来启动。。。Nginx从新读取配置的命令是
1
nginx -s reload
windows下面就是
1
nginx.exe -s reload



Zabbix安装配置
2017-04-02T14:31:38.000Z
zabbix安装配置
安装zabbix
1
yum install -y epel-release
安装rpm包的lamp环境
1
yum install -y  httpd mysql mysql-libs php php-mysql mysql-server php-bcmath php-gd php-mbstring
安装zabbix服务端
1
yum install  zabbix20 zabbix20-agent zabbix20-server  zabbix20-server-mysql zabbix20-web zabbix20-web-mysql net-snmp-devel
启动服务
1
/etc/init.d/zabbix-server start; /etc/init.d/zabbix-agent start; /etc/init.d/httpd start;
修改一下mysql配置文件
1
2
3
4
5
6
7
vim /etc/my.cnf    //修改或增加如下内容

[mysql]
default-character-set = utf8

[mysqld]
character_set_server = utf8
启动mysql服务
1
/etc/init.d/mysqld start
建库，导入数据
1
2
3
4
mysql -uroot -p -e  "create database zabbix"
mysql -uroot -p --default-character-set=utf8 zabbix < /usr/share/zabbix-mysql/schema.sql
mysql -uroot -p --default-character-set=utf8 zabbix < /usr/share/zabbix-mysql/images.sql
mysql -uroot -p --default-character-set=utf8  zabbix < /usr/share/zabbix-mysql/data.sql
网页安装zabbix
浏览器访问 http://ip/zabbix, 默认会有“It is not safe to rely on the system‘s timezone settings ”这样的警告信息，需要vim /etc/php.ini 设置 date.timezone=“Asia/Shanghai”点next
解决相关的报错信息，点retry  (vim /etc/php.ini)
输入mysql相关信息, 首先要测试一下，如果不通过，则需要调试，测试通过后，点next
Name 写127.0.0.1，（可以自定义）点next，再点next，最后点finish
默认管理员账号密码为 admin:zabbix
这时会遇到“zabbix server is not running”这样的错误，需要编辑一下 /etc/zabbix/zabbix_server.conf ，配置DBUser, DBPassword
接入要监控的主机
在客户端上
1
2
3
4
5
6
yum install zabbix20-agent
vim /etc/zabbix_agentd.conf 
//更改Server=服务端ip; 

ServerActive=0.0.0.0:10050
Hostname=xxx
启动客户端
1
etc/init.d/zabbix-agent start
服务端上命令行测试：
1
zabbix_get -s 客户端ip -p10050 -k "system.hostname"
在web界面下，点”configuration” –> “host” –> 右上角点”Create Host”  其中host name,  visible name自定义，可以选择groups，这里默认即可，ip address 写入客户端ip
配置监控项目模板：点“templates”, 点add, 在弹出的小窗口中选择Template OS Linux, 然后点select, 最后点save
自定义templates
Zabbix自带了很多模板，模板中有很多监控项目，比如CPU、网卡、内存、进程等等。使用系统自带模板有点太多了，所以我们可以自定义模板。点configuration 选择 templates，点右上角的create template
Template name和Visible name  自定义，Groups 选择templates, 点save
然后我们去挑选一些项目拷贝到该模板下：比如我们找到Template OS Linux 点一下items,选择我们想要的项目，然后在下面选择copy selected to … 然后点go
Group 选择templates, 找到刚才我们自定义的templates,点copy
点configuration 选择 templates可以看到新建的templates中已经有刚刚我们copy的items了
我们可以使用和上面相同的方法自定义拷贝Triggers（触发器 ）,它用来设置告警的阀值，当然我们也可以自定义编辑它。
例如：监控客户端网卡流量
配置发邮件
1
2
3
4
5
6
7
8
yum install -y sendmail 
mkdir -p /home/zabbix/bin
vim /home/zabbix/bin/baojing.sh //加入内容：

#! /bin/bash
echo "$3" |/bin/mail -s "$2" $1
//保存退出后给予执行权限
chmod +x /home/zabbix/bin/baojing.sh
在zabbix_server.conf配置文件中，有参数AlertScriptsPath和ExternalScripts
AlertScriptsPath=/home/zabbix/bin/ —用户自定义的media types脚本
ExternalScripts=/home/zabbix/bin/ —用户自定义的检查的脚本（item）
这样才能找到你的脚本，因为你在frontend中只是输入脚本的名称，没有路径。
创建mediea types: “Administration” –>”Media types”，点击右上角“Create Media Type”其中Description填”baojing” 或其它自定义名称，Type选择”Script”，Script填”baojing.sh”然后点”Save”.
创建user: “Adimistration” –> “Users”在右上角，选择”Users”，点击”Create User”, alias: test1,自定义name和lastname password:123456;group 选择guest，回到上面点一下media,type 选择baojing，send to 写要发送邮件的邮箱，点add, 最后点save
创建action: “configuration” –> actions,右上角“Create Actions”, Name自定义，我这里写”baojing”,其他默认，然后点右侧的“Operations”下的“New”按钮，“Operation Type”选择“Send message”，“Send Message to”选择一个或多个要发送消息的用户组，Send to Users选择我们之前新增的test1, “Send only to”选择baojing , 点一下add
最后点save。
扩展：
zabbix历史记录乱码问题
zabbix图形中乱码问题
Zabbix自定义监控脚本配置
Zabbix汇总



Nagios 安装和配置
2017-04-01T16:35:21.000Z
Nagios 安装和配置
Nagios官网:http://www.nagios.org
实验环境：一台服务端（IP：192.168.0.200）；一台客户端（IP：192.168.0.201）。
1. Nagios安装 - 服务端（192.168.0.200）
Centos6默认的yum源里没有nagios相关的rpm包，但是我们可以安装一个epel的扩展源：
1
yum install -y epel-release
然后安装nagios相关的包
1
yum install -y httpd nagios nagios-plugins nagios-plugins-all nrpe nagios-plugins-nrpe
设置登录nagios后台的用户和密码：
1
htpasswd -c /etc/nagios/passwd nagiosadmin
检测配置文件
1
nagios -v /etc/nagios/nagios.cfg
启动服务：
1
service httpd start; service nagios start
浏览器访问： http:/192.168.0.200ip/nagios/
2. Nagios安装 - 客户端（192.168.0.201）
在客户端机器上:
1
2
3
4
5
6
yum install -y epel-release
yum install -y nagios-plugins nagios-plugins-all nrpe nagios-plugins-nrpe 

vim /etc/nagios/nrpe.cfg
找到“allowed_hosts=127.0.0.1” 改为 “allowed_hosts=127.0.0.1,192.168.0.200”
找到” dont_blame_nrpe=0” 改为  “dont_blame_nrpe=1”
启动客户端
1
/etc/init.d/nrpe start
3. 监控中心（192.168.0.200）添加被监控主机（192.168.0.201）
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
cd /etc/nagios/conf.d/
vim 192.168.0.201.cfg                   //加入：
define host{
        use                     linux-server            
        host_name           192.168.0.201201
        alias                       0.201
        address                 192.168.0.201
        }

define service{
        use                     generic-service
        host_name               192.168.0.201
        service_description     check_ping
        check_command           check_ping!100.0,20%!200.0,50%
        max_check_attempts 5
        normal_check_interval 1
}

define service{
        use                     generic-service
        host_name               192.168.0.201
        service_description     check_ssh
        check_command           check_ssh
        max_check_attempts 5 ；当nagios检测到问题时，一共尝试检测5次都有问题才会告警，如果该数值为1，那么检测到问题立即告警
        normal_check_interval 1 ；重新检测的时间间隔，单位是分钟，默认是3分钟
        notification_interval 60 ；在服务出现异常后，故障一直没有解决，nagios再次对使用者发出通知的时间。单位是分钟。如果你认为，所有的事件只需要一次通知就够了，可以把这里的选项设为0。 
}

define service{
        use                     generic-service
        host_name               192.168.0.201
        service_description     check_http
        check_command           check_http
        max_check_attempts      5
        normal_check_interval 1
}
以上服务不依赖于客户端nrpe服务，我们可以想象，我们在自己电脑上可以使用ping或者telnet探测远程任何一台机器是否存活、是否开启某个端口或服务。 而当我们想要检测客户端上的某个具体服务的情况时，就需要借助于nrpe了，比如想知道客户端机器的负责或磁盘使用情况。
4.  继续添加服务
服务端
1
2
3
4
5
6
vim /etc/nagios/objects/commands.cfg
//增加：
    define command{
        command_name    check_nrpe
        command_line    $USER1$/check_nrpe -H $HOSTADDRESS$ -c $ARG1$
        }
继续编辑
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
vim /etc/nagios/conf.d/192.168.0.12.cfg
//增加如下内容：

define service{
        use     generic-service
        host_name       192.168.0.12
        service_description     check_load
        check_command           check_nrpe!check_load
        max_check_attempts 5
        normal_check_interval 1
}


define service{
        use     generic-service
        host_name       192.168.0.12
        service_description     check_disk_hda1
        check_command           check_nrpe!check_hda1
        max_check_attempts 5
        normal_check_interval 1
}

define service{
        use     generic-service
        host_name       192.168.0.12
        service_description     check_disk_hda2
        check_command           check_nrpe!check_hda2
        max_check_attempts 5
        normal_check_interval 1
}
说明：
check_nrpe!check_load：这里的check_nrpe就是在commands.cfg刚刚定义的，check_load是远程主机上的一个检测脚本
在远程主机上vim /etc/nagios/nrpe.cfg 搜索check_load，这行就是在服务端上要执行的脚本了，我们可以手动执行这个脚本
把check_hda1更改一下：/dev/hda1 改为 /dev/sda1
再加一行command[check_hda2]=/usr/lib/nagios/plugins/check_disk -w 20% -c 10% -p /dev/sda2
客户端上重启一下nrpe服务:
1
service nrpe restart
服务端也重启一下nagios服务:
1
service nagios restart
5.   配置告警
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
vim /etc/nagios/objects/contacts.cfg 
//增加：

define contact{
        contact_name               123
        use                             generic-contact
        alias                           aming
        email              lishiming2009@139.com
        }


define contact{
        contact_name               456
        use                             generic-contact
        alias                            aaa
        email              aminglinux@139.com
        }


define contactgroup{
        contactgroup_name           common
        alias                                  common
        members                          123,456
        }
然后在要需要告警的服务里面加上contactgroup
1
2
3
4
5
6
7
8
9
10
11
12
define service{
        use     generic-service
        host_name       192.168.0.12
        service_description     check_load
        check_command           check_nrpe!check_load
        max_check_attempts 5
        normal_check_interval 1
        contact_groups        common
        notifications_enabled  1    ；是否开启提醒功能。1为开启，0为禁用。一般，这个选项会在主配置文件（nagios.cfg）中定义，效果相同。
        notification_period   24x7   ；发送提醒的时间段。非常重要的主机（服务）我定义为7×24，一般的主机（服务）就定义为上班时间。如果不在定义的时间段内，无论什么问题发生，都不会发送提醒。        
        notification_options:w,u,c,r   ；这个是service的状态。w为waning， u为unknown, c为critical, r为recover(恢复了），类似的还有一个  host对应的状态：d,u,r   d = 状态为DOWN, u = 状态为UNREACHABLE , r = 状态恢复为OK，需要加入到host的定义配置里。
}
扩展：
调用短信接口
整合微信
6.   配置图形显示 pnp4nagios
安装
1
yum install pnp4nagios rrdtool
配置主配置文件
1
2
3
4
5
6
vim /etc/nagios/nagios.cfg  //修改如下配置

process_performance_data=1   
host_perfdata_command=process-host-perfdata
service_perfdata_command=process-service-perfdata
enable_environment_macros=1
修改commands.cfg
1
2
3
4
5
6
7
8
9
10
11
vim /etc/nagios/objects/commands.cfg  //注释掉原有对process-host-perfdata和process-service-perfdata，重新定义

define command {  
       command_name    process-service-perfdata  
       command_line    /usr/bin/perl /usr/libexec/pnp4nagios/process_perfdata.pl  
}  
  
define command {  
       command_name    process-host-perfdata  
       command_line    /usr/bin/perl /usr/libexec/pnp4nagios/process_perfdata.pl -d HOSTPERFDATA  
}
修改配置文件templates.cfg
1
2
3
4
5
6
7
8
9
10
11
12
vim /etc/nagios/objects/templates.cfg define host {
        name       hosts-pnp
        register   0
        action_url /pnp4nagios/index.php/graph?host=$HOSTNAME$&srv=_HOST_
        process_perf_data               1
}
define service {
        name       srv-pnp
        register   0
        action_url /pnp4nagios/index.php/graph?host=$HOSTNAME$&srv=$SERVICEDESC$
        process_perf_data               1
}
修改host和service配置
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
vim /etc/nagios/conf.d/192.168.0.12.cfg 
把 “define host{
        use                     linux-server” 
改为：
define host{
        use                     linux-server,hosts-pnp

修改对应的service，比如
把
define service{
        use     generic-service
        host_name       192.168.0.12
        service_description     check_disk_hda1
        check_command           check_nrpe!check_hda1
        max_check_attempts 5
        normal_check_interval 1
}
改为：
define service{
        use     generic-service,srv-pnp
        host_name       192.168.0.12
        service_description     check_disk_hda1
        check_command           check_nrpe!check_hda1
        max_check_attempts 5
        normal_check_interval 1
}
重启和启动各个服务：
1
2
3
service nagios restart
service httpd restart
service npcd start
两种访问方法：
ip/nagios/
ip/pnp4nagios/


CentOS上搭建Git服务器
2017-04-01T08:43:10.000Z
Git是一个分布式版本控制软件，原来是linux内核开发者Linus Torvalds为了更好地管理linux内核开发而创立的。发展至今，Git已经成为了一个相当好用的版本管理工具。相比于SVN，如果想要保存一些微小的修改也必须得提交服务器保存才可以，这样使服务器的版本号过多，而Git解决了这个问题，一些小的修改只在本地提交即可，只需最后修改完成后再提交服务器。正是由于这样的便捷性，现在越来越多的社区项目都开始使用Git来取代SVN之类较为传统的版本管理工具进行开发。
使用CentOS搭建Git服务器是一件比较轻松的事儿，本次折腾主要涉及git, gitosis, gitweb的安装配置。其中，gitosis和gitweb是两种比较常用的方式，gitosis是以SSH方式访问和管理git， gitweb是通过http的方式访问和管理。利用这些工具即可满足Git服务器的基本功能。此外比较好的一点是，Git的管理工具几乎不会给服务器带来较大的性能压力。下面正式开始我们的Git安装配置记录。
一、安装Git
1
yum install git
然后进行配置：
1
2
useradd --home /home/git git
passwd git
创建完用户后就可以切换到git用户下进行后面的设置，如用户名和邮箱：
1
2
3
su git
git config --global user.name "somebody"
git config --global user.email "somebody@example.com"
设置默认将会保存在~/.gitconfig文件中。
此时，Git的功能就已经可以使用了。为了方便后面的操作，可以先来创建一个空版本库。
1
mkdir ~/repo
然后建立项目目录
1
mkdir ~/repo/huhamhire-hosts
切换到项目目录，并进行初始化
1
2
cd ~/repo/huhamhire-hosts
git init -bare
至此，一个初始的空项目版本库就配置完成了，后面安装了gitosis之后便可向库中推送我们的代码库内容。
二、安装gitosis
在安装之前，可以看一下gitosis的实现原理：
浅谈Gitosis实现原理
先切换回root权限。
1
su root
并先安装python-setuptool
1
yum install python-setuptools
然后开始安装gitosis，值得注意的是gitosis的安装程序本身就是由git管理的，需要使用git来获取。这里在/tmp目录下进行相关的安装操作：
1
2
cd /tmp
git clone https://github.com/res0nat0r/gitosis.git
接下来进入下载的gitosis版本库进行安装:
1
2
cd gitosis
python setup.py install
安装完成后，便进入对gitosis的设置阶段。由于gitosis需要通过SSH进行管理，所以需要创建SSH密钥对，并将公钥放在服务器端，私钥放在客户端。一般的流程是客户端创建完密钥后，将公钥传到服务器上生效。不过，偷懒的话直接在服务器上操作问题也不大。
切换到git用户并建立文件夹.ssh：
1
2
su git
mkdir /home/git/.ssh
一定记得，在客户机上生成公钥，上传到服务器，或者在服务器上生成，下载到客户机。
进入~/.ssh目录并使用ssh-keygen生成公钥：cd /home/git/.ssh
1
ssh-keygen -t rsa
注意不能忘记私钥的密码。默认会生成~/.ssh/id_rsa.pub公钥文件。
有了密钥以后便可初始化gitosis，使gitosis获得对Git的管理权限：
1
gitosis-init < /home/git/.ssh/id_rsa.pub
初始化之后，会在/home/git/repositories创建gitosis-admin.git项目，可以通过维护这个项目来对gitosis进行配置。
除此以外，还需要对gitosis-admin.git/hooks/post-update目录赋上特殊权限：
1
chmod u+x /home/git/repositories/gitosis-admin.git/hooks/post-update
至此，服务器端的gitosys配置就完成了。
三、设置并使用gitosys
在服务器端完成了gitosys的配置之后，便可在客户端进行接下来的设置，以便使用Git服务器。
较为正规的做法是在客户端通过gitosis-admin版本库做管理设置，之后提交到服务器使项目权限生效，当然也可以使用操作系统的ssh登录方式进行验证，不过这里仅介绍前面一种方法。
在进行以下操作时，需要确认一下，你的公钥是不是已经放在客户机~/.ssh/目录下。如果你也在用github的话，那么你需要设置一下多公钥共存的东西。.ssh/config，在这个文件中写入：
1
2
3
4
5
6
7
8
9
10
11
12
13
Host github.com
    HostName github.com
    User git
    IdentityFile C:/Users/abc/.ssh/id_rsa
Host git.oschina.net
    HostName git.oschina.net
    User git
    IdentityFile C:/Users/abc/.ssh/id_rsa_a
Host abc.ueder.info
    HostName abc.ueder.info
    User git
    Port 1000
    IdentityFile C:/Users/abc/.ssh/id_rsa_new
如我就使用了好几个git服务，每个都有自己的公钥，需要配置文件来区分开来，并且我自己的服务器ssh端口已经不是默认端口，需要在配置文件中声明，否则在每次clone的时候要声明端口。
在客户机上下载gitosis-admin版本库，这里以linux客户机为例：
1
git clone git@VPS的IP/Domain:/home/git/repositories/gitosis-admin.git
获取完成后对gitosis-admin/gitosis.conf文件进行设置，以上面新建的项目为例，新增：
1
2
3
[group huhamhire-hosts]
writable = huhamhire-hosts
members = hamhire@myhost
随后要将客户端的公钥放到keydir目录下，并随后提交设置到服务器：
1
2
3
4
5
6
cp ~/.ssh/id_rsa.pub ~/gitosis-admin/keydir/hamhire@myhost.pub
    
cd ~/gitosis-admin
git add ./
git commit -a -m "add new repo"
git push
由于之前已经在/home/git/repo/目录下设置了huhamhire-hosts的版本库位置，所以可以直接进行推送操作。
在本例中可以通过hamhire@myhost:/home/git/repo/huhamhire-hosts的路径来提交项目。
至此，gitosys的配置全部完成。
四、安装gitweb
在配置完成了git服务器以后，如果需要方便在线查看，使用gitweb来提供一个简单网页版的版本显示界面是一个不错的选择。
在centos 下安装gitweb如下：
1
2
3
4
5
6
7
8
9
yum install fcgi-devel
    
cd /usr/local/src/
git clone git://github.com/gnosek/fcgiwrap.git
cd fcgiwrap
autoreconf -i
./configure
make
make install
至此，fcgiwrap已经安装到 /usr/local/sbin/fcgiwrap
然后再安装spawn-fcgi
1
yum install spawn-fcgi
安装好后:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
vim /etc/sysconfig/spawn-fcgi
# 修改文件为：

# You must set some working options before the "spawn-fcgi" service will work.
# If SOCKET points to a file, then this file is cleaned up by the init script.
#
# See spawn-fcgi(1) for all possible options.
#
# Example :
#SOCKET=/var/run/php-fcgi.sock
#OPTIONS="-u apache -g apache -s $SOCKET -S -M 0600 -C 32 -F 1 -P /var/run/spawn-fcgi.pid -- /usr/bin/php-cgi"
FCGI_SOCKET=/var/run/fcgiwrap.socket
FCGI_PROGRAM=/usr/local/sbin/fcgiwrap
FCGI_USER=nginx
FCGI_GROUP=nginx
FCGI_EXTRA_OPTIONS="-M 0700"
OPTIONS="-u $FCGI_USER -g $FCGI_GROUP -s $FCGI_SOCKET -S $FCGI_EXTRA_OPTIONS -F 1 -P /var/run/spawn-fcgi.pid -- $FCGI_PROGRAM"
然后设置开机运行：
1
2
chkconfig --levels 2345 spawn-fcgi on
/etc/init.d/spawn-fcgi start
这里已经完成了fcgi的安装运行。如果你用的nginx，还需要对nginx.conf进行配置，才能将.cgi的请求转发给fcgiwrap.socket
1
2
3
4
5
6
7
8
9
10
11
12
13
14
location /cgi-bin/ {
 # Disable gzip (it makes scripts feel slower since they have to complete
 # before getting gzipped)
 gzip off;
 # Set the root to /usr/lib (inside this location this means that we are
 # giving access to the files under /usr/lib/cgi-bin)
 root /var/www/www.example.com;
 # Fastcgi socket
 fastcgi_pass unix:/var/run/fcgiwrap.socket;
 # Fastcgi parameters, include the standard ones
 include /etc/nginx/fastcgi_params;
 # Adjust non standard parameters (SCRIPT_FILENAME)
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }
最后重启nginx就可以了。


linux监控之cacti
2017-04-01T05:56:18.000Z
cacti 重图形，有数据历史，需用到数据库支持，支持web配置，默认不支持告警，可以加插件。
cacti安装配置
1. 首先要安装epel扩展源
1
yum install  epel-release
2. （lamp）然后分别安装httpd、php、mysql
1
yum install -y  httpd php php-mysql mysql mysql-server mysql-devel php-gd  libjpeg libjpeg-devel libpng libpng-devel
3. 安装cacti  net-snmp  rrdtool
1
yum install -y cacti  net-snmp  net-snmp-utils  rrdtool
4. 启动服务：
1
2
3
/etc/init.d/mysqld start
/etc/init.d/httpd  start
/etc/init.d/snmpd start
5. 编辑httpd配置文件
1
2
3
4
vim /etc/httpd/conf.d/cacti.conf  

# 把"Deny from all" 改为  "Allow from all"
/etc/init.d/httpd  restart
6.  导入数据创建cacti库
1
2
3
mysql -uroot  -e "create database cacti" #创建数据库
mysql -uroot -e "grant all on cacti.* to 'cacti'@'127.0.0.1' identified by 'cacti';" #创建cacti用户
mysql -uroot cacti < /usr/share/doc/cacti-0.8.8b/cacti.sql #导入cacti文件
7.  编辑cacti配置文件
1
2
3
4
5
6
7
8
9
vim /usr/share/cacti/include/config.php  更改如下：
$database_type = "mysql";
$database_default = "cacti";
$database_name = "cacti";
$database_hostname = "127.0.0.1";
$database_username = "cacti";
$database_password = "cacti";
$database_port = "3306";
$database_ssl = false;
8. web访问cacti并安装
http://192.168.209.131/cacti/
点两下“next” 和一次”Finish“ 即可
输入admin   admin 登录，重新设置新的密码
9. 执行poller.php, 生成图形， 加入计划任务
1
2
3
/usr/bin/php /usr/share/cacti/poller.php添加cron任务
//crontab -e  增加：
*/5 * * * *  /usr/bin/php /usr/share/cacti/poller.php
以下10-12步骤在客户端机器上操作
10. 安装snmp
1
yum install -y net-snmp
11. 修改snmpd.conf
修改syslocation以及syscontact, 其中syslocation 可以写本机ip，syscontact写管理员邮箱
1
2
syslocation 192.168.209.131
syscontact Root graped@aliyun.com
12. 启动snmp
1
service  snmpd  start
13.  登录cacti管理后台，点console , 再点Device， 在右上角点”Add“
Description  写本机ip或你自定义一个名字
Hostname  写本机ip
Host Template  选ucd/net  SNMP Host
SNMP Version  选Version 2
点右下角的create
点右上角的”Create Graphs for this Host“
Graph Types:  选择SNMP - Interface Statistics
在下面框中选择要监控的网卡，比如我选择eth0, 在最右侧小方块里打对勾，然后点右下角的create
（如果在这一步找不到网卡，可以根据这个帖子修改配置文件：cacti监控找到网卡的方法）
Graph Types:  再选择 Graph Template Based
在下面的框中，选择你要监控的项目，比如ucd/net - Load Average
在右侧小方块中打对勾，然后点右下角的create
14. 点左侧的Graph Trees
选中”Default Tree“
点右上角的Add
Tree Item Type 选择 ”Host“
Host 选择我们刚刚增加的那个机器ip
点右下角的create
15. 点左上角的Graphs
在左侧可以看到
Defaut Tree下面已经增加了我们刚刚添加的主机，图形一开始不会那么快出来，要等一小会才可以。

DInG_BloG

Nginx Rewrite和Return

Rewrite配置（一）

rewrite相关指令

if指令

break和last指令

404 Not Found

404 Not Found

Nginx rewrite配置（二）

302 Found

nginx全局变量

return用法

返回状态码

403 Forbidden

返回字符串

返回url

Nginx 虚拟主机

Nginx虚拟主机配置

Nginx默认虚拟主机

403 Forbidden

虚拟主机配置规范

403 Forbidden

基于不同端口的虚拟主机

Nginx配置文件详解

nginx.conf全局配置

events配置部分

http配置部分

python的安装和pycharm的使用

环境安装

在windows 10上安装ptyhon 2.7.13和3.7.0

在Centos7.3上安装python2和python3

在Window 10上安装安装 PyCharm

设置PyCharm 抬头

第一个python例子

Pycharm常用快捷键

如何去运行一个python程序

使用ansible-playbook推送安装nginx

使用ansible-playbook推送安装nginx

1. 思路：

2. 流程图如下：

3. 执行配置过程

3.1 编译安装nginx详见： 编译安装Nginx

3.2 创建ansible roles目录结构

3.3 将安装好的nginx程序包打包，并放到 $/install/files/ 下面，启动脚本 放入$/install/templates中，

3.4 在common目录下定义安装nginx的依赖包任务

3.5 定义变量

3.6 定义拷贝操作

3.7 创建安装总线

3.8 创建执行总线

3.9 创建入口配置文件

Ansible详解

一、Ansible介绍

1.Ansible的安装配置

1.1 yum安装ansible

2.配置ansible

2.1 在server1 上生成公钥

2.2 ssh-copy-id命令来复制Ansible公钥到本机和server2节点中,server3节点不做处理。

2.3 修改vi /etc/ansible/hosts

3. 使用Ansible远程执行命令

3.1 有时候会遇见如下图报错

4. 使用Ansible 远程执行脚本

需要注意的是：

5. 使用Ansible拷贝文件或者目录

5.1 拷贝目录

5.1.1其中各参数表示的意义是：

5.1.2 需要注意的是:

5.2 拷贝文件

5.2.2 需要注意的是：

6. 使用ansible管理任务计划

6.1 在serverr1上创建任务管理计划

6.2 查看在server1上创建的任务计划

6.3 删除在server1上创建的计划任务

6.4 查看server1上创建的计划任务是否已经被删除

6.5 注意，通过Ansible创建的计划任务不可以手工更改，否则之后就没法再进行其他操作了

7. 使用ansible安装包和管理服务

7.1 使用ansible安装httpd服务

7.2 使用ansible卸载httpd服务

7.3 使用ansible启动httpd服务

Anbsible Playbook详解

1. 编写配置文件

3.1 编译安装nginx详见：编译安装Nginx

3.3 将安装好的nginx程序包打包，并放到 `$/install/files/` 下面，启动脚本放入`$/install/templates`中，

2.3 修改`vi /etc/ansible/hosts`