## nginx简介


### 初识Nginx
Nginx是由俄罗斯国立莫斯科鲍曼科技大学在1994年毕业的学生为俄罗斯rambler.ru公司开发的，开发工作最早从2002年开始，第一次公开发布时间是2004年10月4日，版本号是0.1.0  

2019年3月11日F5 与 NGINX达成协议,F5 将收购 NGINX 的所有已发行股票，总价值约为 6.7 亿美元。6.7亿美金约合44.97亿人民币,nginx核心模块代码长度198430（包括空格、注释），所以一行代码约为2.2万人民币

官网地址 www.nginx.org

Nginx历经十几年的迭代更新（https://nginx.org/en/CHANGES）， 目前功能已经非常完善且运行稳
定，分为社区版本和商业版，另外Nginx的社区版本分为开发版（奇数）、最新稳定版（偶数）和过期
版，nginx以功能丰富著称，它即可以作为http服务器，也可以作为反向代理服务器或者邮件服务器，能
够快速的响应静态网页的请求，支持FastCGI/SSL/Virtual Host/URL Rwrite/Gzip/HTTP Basic Auth/http 或者TCP的负载均衡(1.9版本以上且开启stream模块)等功能，并且支持第三方的功能扩展。
天猫 淘宝 京东 小米 163 新浪等一线互联网公司都在用Nginx或者进行二次开发 

为什么nginx在linux上安装就比windows上块？为什么nginx比其他web服务有优势？
1. windows只支持select的I/O模型，最大并发限制1024。
2. poll模型是linux的基本模型，windows不支持，是select的升级版
3. epoll模型是Nginx服务器支持的最高性能的事件驱动库之一，是公认的非常优秀的事件驱动模型，它和select和poll有很大的区别，epoll是poll的升级版，但是与poll有很大的区别.epoll的处理方式是创建一个待处理的事件列表，然后把这个列表发给内核，返回的时候在去轮询检查这个表，以判断事件是否发生，epoll支持一个进程打开的最大事件描述符的上限是系统可以打开的文件的最大数，同时epoll库的I/O效率不随描述符数目增加而线性下降，因为它只会对内核上报的“活跃”的描述符进行操作。

**Nginx功能：**
- 静态的web资源服务器html，图片，js，css，txt等静态资源
- http/https协议的反向代理
- 结合FastCGI/uWSGI/SCGI等协议反向代理动态资源请求
- tcp/udp协议的请求转发（反向代理）
- imap4/pop3协议的反向代理

**Nginx进程：**  
Nginx是多进程模型，是由一个Master主进程和Worker工程进程组成  

Master主进程：
- Master对外是接收外部的操作信号，对内根据操作的不同，通过信号管理Worker
- 读取Nginx 配置文件并验证其有效性和正确性
- 接受外界指令，比如重启、升级及退出服务器等指令
- 不中断服务，实现平滑升级，重启服务并应用新的配置

Worker工作进程：
- 所有Worker进程都是平等的
- Work进程数一般和CPU核心数一致，充分利用CPU资源
- 接受主进程指令，比如重启、升级和退出等

**Nginx启动和http建立连接：**
- Nginx启动时，Master进程加载配置文件
- Master初始化监听的socket
- Master主进程fork出多个Worker进程
- Worker竞争新的连接，获取方通过三次握手建立Socket连接并处理请求

## 一、Nginx的安装
工作中不建议使用通过源安装的方式，很多第三方模块都无法使用，不方便业务上的一些使用。而且源安装的方式版本比较旧。

:::info{title="源安装"}
rhel系列：yum -y install nginx
注：centos7需要提前配置好epel源，yum -y install epel-release
debian系列： apt -y install nginx
:::
**编译安装：**  
```sh
#1、安装编译的相关包
yum -y install gcc pcre-devel openssl-devel zlib-devel
#2、创建用户
useradd -s /sbin/nologin nginx
#3、下载软件包到本机
wget http://nginx.org/download/nginx-1.20.0.tar.gz
#4、解包进入目录
tar xf nginx-1.20.0.tar.gz;cd nginx-1.20.0/
#5、编译,--prefix是指定安装目录，--user和--group是指定用户和组，后面的--with都是模块，要使用必须在编译的时候加上
./configure --prefix=/apps/nginx --user=nginx --group=nginx --with-http_ssl_module --with-http_v2_module --with-http_realip_module --with-http_stub_status_module --with-http_gzip_static_module --with-pcre --with-stream --with-stream_ssl_module --with-stream_realip_module
#6、安装
make && make install;chown -R nginx.nginx /apps/nginx

#7、编译安装是没有nginx.service文件的，需要手动创建，可参考源安装方式的nginx.service文件
cat /lib/systemd/system/nginx.service 
[Unit]
Description=The nginx HTTP and reverse proxy server
After=network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/apps/nginx/logs/nginx.pid
ExecStartPre=/bin/rm -f /apps/nginx/logs/nginx.pid
ExecStartPre=/apps/nginx/sbin/nginx -t
ExecStart=/apps/nginx/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
KillSignal=SIGQUIT
TimeoutStopSec=5
KillMode=process
PrivateTmp=true
LimitNOFILE=100000

[Install]
WantedBy=multi-user.target
#8、加载service文件并设为开机自启
systemctl daemon-reload;systemctl enable --now nginx
```

## 二、配置文件详解

:::info{title="配置文件位置"}
1、包安装的配置文件在/etc/nginx/nginx.conf  
2、编译安装的看具体安装文件，这里是/apps/nginx/conf/nginx.conf  
3、也可在主配置文件中添加子配置文件目录，在最后一个花括号前添加
include /apps/nginx/conf.d/*.conf; 
:::

### 2.1 主配置文件分为四部分
```nginx
main block：主配置段，即全局配置段，对http,mail都有效

#事件驱动相关的配置
event {
...
}
#http/https 协议相关配置段
http {
...
}
#默认配置文件不包括下面两个块
#mail 协议相关配置段
mail {
...
}
#stream 服务器相关配置段
stream {
...
}

```
### 2.2 配置文件格式说明
```nginx
#全局配置端，对全局生效，主要设置nginx的启动用户/组，启动的工作进程数量，工作模式，Nginx的PID路径，日志路径等。
user nginx nginx;
worker_processes 1; #启动工作进程数数量
events { 
    #events设置快，主要影响nginx服务器与用户的网络连接，比如是否允许同时接受多个网络连接，使用哪种事件驱动模型处理请求，每个工作进程可以同时支持的最大连接数，是否开启对多工作进程下的网络连接进行序列化等。
worker_connections 1024; #设置单个nginx工作进程可以接受的最大并发，作为web服务器的时候最大并发数为worker_connections * worker_processes，作为反向代理的时候为(worker_connections * worker_processes)/2
}
    http { 
        #http块是Nginx服务器配置中的重要部分，缓存、代理和日志格式定义等绝大多数功能和第三方模块都可以在这设置，http块可以包含多个server块，而一个server块中又可以包含多个location块，server块可以配置文件引入、MIME-Type定义、日志自定义、是否启用sendfile、连接超时时间和单个链接的请求上限等。
        
    include mime.types;
    default_type application/octet-stream;
    sendfile on; #作为web服务器的时候打开sendfile加快静态文件传输，指定是否使用sendfile系统调用来传输文件,sendfile系统调用在两个文件描述符之间直接传递数据(完全在内核中操作)，从而避免了数据在内核缓冲区和用户缓冲区之间的拷贝，操作效率很高，被称之为零拷贝，硬盘 >>kernel buffer (快速拷贝到kernelsocket buffer) >>协议栈。
    
    keepalive_timeout 65; #长连接超时时间，单位是秒
    
    server { #设置一个虚拟机主机，可以包含自己的全局快，同时也可以包含多个location模块。比如本虚拟机监听的端口、本虚拟机的名称和IP配置，多个server 可以使用一个端口，比如都使用80端口提供web服务、listen 80; #配置server监听的端口server_name localhost; #本server的名称，当访问此名称的时候nginx会调用当前serevr内部的配置进程匹配。
    
        location / { #location其实是server的一个指令，为nginx服务器提供比较多而且灵活的指令，都是在location中体现的，主要是基于nginx接受到的请求字符串，对用户请求的UIL进行匹配，并对特定的指令进行处理，包括地址重定向、数据缓存和应答控制等功能都是在这部分实现，另外很多第三方模块的配置也是在location模块中配置。
        
    root html; #相当于默认页面的目录名称，默认是安装目录的相对路径，可以使用绝对路径配置。
    index index.html index.htm; #默认的页面文件名称
}
    error_page 500 502 503 504 /50x.html; #错误页面的文件名称
        location = /50x.html { #location处理对应的不同错误码的页面定义到/50x.html，这个跟对应其server中定义的目录下。
    root html; #定义默认页面所在的目录
    }
}
#和邮件相关的配置
#mail {
# ...
# } mail 协议相关配置段
#tcp代理配置，1.9版本以上支持
#stream {
# ...
# } stream 服务器相关配置段

#导入其他路径的配置文件
#include /apps/nginx/conf.d/*.conf
}

```
### 2.3 配置文件相关优化
```nginx
#1、更改记录日志格式
http {
    #以json格式记录nginx访问日志
    log_format access_json '{"@timestamp":"$time_iso8601",'
        '"host":"$server_addr",'
        '"clientip":"$remote_addr",'  #客户端IP
        '"size":$body_bytes_sent,'
        '"responsetime":$request_time,' #总的处理时间
        '"upstreamtime":"$upstream_response_time",'
        '"upstreamhost":"$upstream_addr",' #后端应用服务器处理时间
        '"http_host":"$host",'
        '"uri":"$uri",'
        '"xff":"$http_x_forwarded_for",'
        '"referer":"$http_referer",'
        '"tcp_xff":"$proxy_protocol_addr",'
        '"http_user_agent":"$http_user_agent",'
        '"status":"$status"}';
        access_log /apps/nginx/logs/access_json.log access_json;

}

#2、其他
    sendfile on; #开启文件高效传输模式
    tcp_nopush     on;当有数据时，先别着急发送, 确保数据包已经装满数据, 避免了网络拥塞，和sendfile一起开启
    keepalive_timeout  60; #超时时间
    gzip on;#开启gzip压缩
    gzip_comp_level 5;#压缩比1-9，默认1
    gzip_min_length 1k;#压缩文件的最小值
    gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/gif image/png;
    gzip_vary on;#响应报文头部插入Vary:Accept-Encoding,一般建议打开 
    client_max_body_size 200M; #允许最大上传文件
```
## 三、案例：使用nginx实现反向代理的动静分离

### 3.1 流程图

![反向代理流程图.jpg](http://vanblog.ztunan.top/static/img/8b3a868de95ac51cdd979f10568ccbb9.%E5%8F%8D%E5%90%91%E4%BB%A3%E7%90%86%E6%B5%81%E7%A8%8B%E5%9B%BE.jpg)
### 3.2 配置
10.0.0.8:
```nginx
vim /apps/nginx/conf/conf.d/static.conf
    location / {
        proxy_pass http://10.0.0.28;
        index index.html;
}
    location ~ \.php$ {
        root /data/php;
        fastcgi_pass 10.0.0.18:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
}
```
10.0.0.18：
```sh
安装php环境，使用yum -y install php-fpm即可，安装完毕后打开服务，systemctl start php-fpm
```
10.0.0.28:
```sh
#安装apache
yum -y install httpd
#启动服务
systemctl start httpd
#使用默认页面即可
```

### Nginx的用法还有很多，比如反向代理的负载均衡，使用upstream，添加两个服务器。rewrite重定向80端口到443端口，return指定URL等功能。后面的文章里在一一说明。

nginx介绍

## mysql主从复制：



**环境：两台rocky8.5，主节点：10.0.0.136，从节点：10.0.0.138  
安装mysql使用的脚本，在网站另一篇文章mysql脚本安装内。  
安装完mysql8.0后发现无法进入数据库，检查后发现libtinfo.so.5在mysql的依赖库中显示为not found  
解决办法：  
ln -s /usr/lib64/libtinfo.so.6.1 /usr/lib64/libtinfo.so.5  
再次使用mysql -uroot -p 后进入数据库。**  

:::info{title="注意"}
**重点**：mysql主从复制尽量是版本一致，如果不一致：那从节点版本必须必主节点高。不然无法实现主从复制。  
1）主从复制主节点需要做四步：设置server ID；启用二进制日志；创建复制账号并授权；备份数据库；  
2）从节点需要配置：安装数据库;配置my.cnf文件，设置slave id，设置read-only=yes；修改主节点备份文件中的主节点服务器信息；
:::

:::tip{title="提示"}
1）临时关闭二进制日志，因为还原时会产生二进制日志，但是这些二进制日志没用,setql_log_bin=off; 还原数据库；开启二进制日志,set sql_log_bin=on;  
2）执行change master to 指向master ip 同步用户密码、端口、二进制日志名称及日志开始位置数字
3）查看slave状态；开启主从复制；   
4）start slave；查看主节点状态show processlist;##验证sql线程和IO线程  
##########从节点重启或者关机再开机，会自动同步主数据库数据
:::
		
### 1.1主节点配置
```sh
10.0.0.136（主节点）：
1）配置my.cnf
[mysqld]
port=3306
server-id=136 #全局唯一
log-bin=/data/mysql/mysql-bin #启用二进制日志
datadir=/data/mysql
socket=/data/mysql/mysql.sock
log-error=/data/mysql/mysql.log
pid-file=/data/mysql/mysql.pid
[client]
socket=/data/mysql/mysql.sock
2）查看二进制文件和位置开始复制
mysql> show master status;
+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000002 |      815 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)
3)创建和授权拥有复制权限的账号（从节点也需要做这步且过程一致）,mysql8.0要分成两步
create user repluser@'10.0.0.%' identified by '密码';
grant replication slave on *.* to repluser@'10.0.0.%';
flush privileges;
```
### 1.2从节点配置
```sh
10.0.0.138（从节点）：
1）配置my.cnf
[mysqld]
server-id=138
log-bin=/data/mysql/bin-log
datadir=/data/mysql
socket=/data/mysql/mysql.sock
log-error=/data/mysql/mysql.log
pid-file=/data/mysql/mysql.pid
read-only=yes #限制从服务器为只读，但是对超级用户权限的用户无效
[client]
socket=/data/mysql/mysql.sock
2)创建和授权拥有复制权限的账号，和主节点步骤一致。这步是为了防止后期主节点挂了从节点可提升为主节点而设置的。
3）这里因为是干净的数据库，就不关闭binlog日志了，如果是运行了一段时间的日志，那就要先关闭binlog日志，不然开启复制后会产生大量无用的二进制日志
直接在数据库里执行：
CHANGE MASTER TO
MASTER_HOST='10.0.0.136', #主节点地址
MASTER_USER='repluser', #主节点复制账号
MASTER_PASSWORD='密码', #密码
MASTER_PORT=3306, #端口
MASTER_LOG_FILE='mysql-bin.000002', MASTER_LOG_POS=815；#这里的名称和815是根据上面主节点使用show master status;查看的。
```
### 1.3 最终结果
```sh
启动并查看状态： start slave;
mysql> show slave status\G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for source to send event
                  Master_Host: 10.0.0.136
                  Master_User: repluser
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000002
          Read_Master_Log_Pos: 815
               Relay_Log_File: rocky-relay-bin.000002
                Relay_Log_Pos: 324
        Relay_Master_Log_File: mysql-bin.000002
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB: 
          Replicate_Ignore_DB: 
           Replicate_Do_Table: 
       Replicate_Ignore_Table: 
      Replicate_Wild_Do_Table: 
  Replicate_Wild_Ignore_Table: 
                   Last_Errno: 0
                   Last_Error: 
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 815
              Relay_Log_Space: 533
              Until_Condition: None
               Until_Log_File: 
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File: 
           Master_SSL_CA_Path: 
              Master_SSL_Cert: 
            Master_SSL_Cipher: 
               Master_SSL_Key: 
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error: 
               Last_SQL_Errno: 0
               Last_SQL_Error: 
  Replicate_Ignore_Server_Ids: 
             Master_Server_Id: 136
                  Master_UUID: d8d3bb3e-3b13-11ed-916b-000c29766fc2
             Master_Info_File: mysql.slave_master_info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Replica has read all relay log; waiting for more updates
           Master_Retry_Count: 86400
                  Master_Bind: 
      Last_IO_Error_Timestamp: 
     Last_SQL_Error_Timestamp: 
               Master_SSL_Crl: 
           Master_SSL_Crlpath: 
           Retrieved_Gtid_Set: 
            Executed_Gtid_Set: 
                Auto_Position: 0
         Replicate_Rewrite_DB: 
                 Channel_Name: 
           Master_TLS_Version: 
       Master_public_key_path: 
        Get_master_public_key: 0
            Network_Namespace: 
```

:::info{title="注意"}
判断主从复制是否成功主要查看两个SQL线程是否为yes。  
如果是从库和主库都是新安装的，用上述方法。  
如果主库已经运行了一段时间再加从库，那要先把主库的数据库备份后还原到从库后，再指定change master to等设置。  
注意：备份和复制的时候关闭binlog日志，做完备份还原后再打开。
:::

mysql主从复制

## 一些日志常用分析命令



**不一定通用，但是复用性很高。当然，也取决于日志保存格式，毕竟现在很多应用记录日志都使用json格式，那样最好使用elk来分析最好。**
```sh
1、查看有多少个IP访问：
awk '{print $1}' log_file|sort|uniq|wc -l

2、查看某一个页面被访问的次数：
grep "/index.php" log_file | wc -l

3、查看每一个IP访问了多少个页面：
awk '{++S[$1]} END {for (a in S) print a,S[a]}' log_file > log.txt
sort -n -t ' ' -k 2 log.txt 配合sort进一步排序

4、将每个IP访问的页面数进行从小到大排序：
awk '{++S[$1]} END {for (a in S) print S[a],a}' log_file | sort -n

5、查看某一个IP访问了哪些页面：
grep ^111.111.111.111 log_file| awk '{print $1,$7}'

6、去掉搜索引擎统计的页面：
awk '{print $12,$1}' log_file | grep ^\"Mozilla | awk '{print $2}' |sort | uniq | wc -l

7、查看2015年8月16日14时这一个小时内有多少IP访问:
awk '{print $4,$1}' log_file | grep 16/Aug/2015:14 | awk '{print $2}'| sort | uniq | wc -l

8、查看访问前十个ip地址
awk '{print $1}' |sort|uniq -c|sort -nr |head -10 access_log
uniq -c 相当于分组统计并把统计数放在最前面
cat access.log|awk '{print $1}'|sort|uniq -c|sort -nr|head -10
cat access.log|awk '{counts[$(11)]+=1}; END {for(url in counts) print counts[url], url}

9、访问次数最多的10个文件或页面
cat log_file|awk '{print $11}'|sort|uniq -c|sort -nr | head -10
cat log_file|awk '{print $11}'|sort|uniq -c|sort -nr|head -20
awk '{print $1}' log_file |sort -n -r |uniq -c | sort -n -r | head -20
访问量最大的前20个ip

10、通过子域名访问次数，依据referer来计算，稍有不准
cat access.log | awk '{print $11}' | sed -e ' s/http:\/\///' -e ' s/\/.*//' | sort | uniq -c | sort -rn | head -20

11、列出传输大小最大的几个文件
cat www.access.log |awk '($7~/\.php/){print $10 " " $1 " " $4 " " $7}'|sort -nr|head -100

12、列出输出大于200000byte(约200kb)的页面以及对应页面发生次数
cat www.access.log |awk '($10 > 200000 && $7~/\.php/){print $7}'|sort -n|uniq -c|sort -nr|head -100

13、如果日志最后一列记录的是页面文件传输时间，则有列出到客户端最耗时的页面
cat www.access.log |awk '($7~/\.php/){print $NF " " $1 " " $4 " " $7}'|sort -nr|head -100

14、列出最最耗时的页面(超过60秒的)的以及对应页面发生次数
cat www.access.log |awk '($NF > 60 && $7~/\.php/){print $7}'|sort -n|uniq -c|sort -nr|head -100

15、列出传输时间超过 30 秒的文件
cat www.access.log |awk '($NF > 30){print $7}'|sort -n|uniq -c|sort -nr|head -20

16、列出当前服务器每一进程运行的数量，倒序排列
ps -ef | awk -F ' ' '{print $8 " " $9}' |sort | uniq -c |sort -nr |head -20

17、查看apache当前并发访问数
对比httpd.conf中MaxClients的数字差距多少
netstat -an | grep ESTABLISHED | wc -l

18、可以使用如下参数查看数据
ps -ef|grep httpd|wc -l
1388
统计httpd进程数，连个请求会启动一个进程，使用于Apache服务器。
表示Apache能够处理1388个并发请求，这个值Apache可根据负载情况自动调整
netstat -nat|grep -i "80"|wc -l
4341
netstat -an会打印系统当前网络链接状态，而grep -i “80”是用来提取与80端口有关的连接的，wc -l进行连接数统计。
最终返回的数字就是当前所有80端口的请求总数
netstat -na|grep ESTABLISHED|wc -l
376
netstat -an会打印系统当前网络链接状态，而grep ESTABLISHED 提取出已建立连接的信息。然后wc -l统计
最终返回的数字就是当前所有80端口的已建立连接的总数。
netstat -nat||grep ESTABLISHED|wc -l
可查看所有建立连接的详细记录

19、输出每个ip的连接数，以及总的各个状态的连接数
netstat -n | awk '/^tcp/ {n=split($(NF-1),array,":");if(n<=2)++S[array[(1)]];else++S[array[(4)]];++s[$NF];++N} END {for(a in S){printf("%-20s %s\n", a, S[a]);++I}printf("%-20s %s\n","TOTAL_IP",I);for(a in s) printf("%-20s %s\n",a, s[a]);printf("%-20s %s\n","TOTAL_LINK",N);}'

20、其他的收集
分析日志文件下 2012-05-04 访问页面最高 的前20个 URL 并排序
cat access.log |grep '04/May/2012'| awk '{print $11}'|sort|uniq -c|sort -nr|head -20

查询受访问页面的URL地址中 含有 www.abc.com 网址的 IP 地址
cat access_log | awk '($11~/\www.abc.com/){print $1}'|sort|uniq -c|sort -nr

获取访问最高的10个IP地址 同时也可以按时间来查询
cat linewow-access.log|awk '{print $1}'|sort|uniq -c|sort -nr|head -10

时间段查询日志时间段的情况
cat log_file | egrep '15/Aug/2015|16/Aug/2015' |awk '{print $1}'|sort|uniq -c|sort -nr|head -10

分析 2015/8/15 到 2015/8/16 访问”/index.php?g=Member&m=Public&a=sendValidCode”的IP倒序排列
cat log_file | egrep '15/Aug/2015|16/Aug/2015' | awk '{if($7 == "/index.php?g=Member&m=Public&a=sendValidCode") print $1,$7}'|sort|uniq -c|sort -nr
($7~/.php/) $7里面包含.php的就输出,本句的意思是最耗时的一百个PHP页面
cat log_file |awk '($7~/\.php/){print $NF " " $1 " " $4 " " $7}'|sort -nr|head -100

列出最最耗时的页面(超过60秒的)的以及对应页面发生次数
cat access.log |awk '($NF > 60 && $7~/\.php/){print $7}'|sort -n|uniq -c|sort -nr|head -100

统计网站流量（G)
cat access.log |awk '{sum+=$10} END {print sum/1024/1024/1024}'

统计404的连接
awk '($9 ~/404/)' access.log | awk '{print $9,$7}' | sort

统计http status
cat access.log |awk '{counts[$(9)]+=1}; END {for(code in counts) print code, counts[code]}'
cat access.log |awk '{print $9}'|sort|uniq -c|sort -rn

每秒并发
watch "awk '{if($9~/200|30|404/)COUNT[$4]++}END{for( a in COUNT) print a,COUNT[a]}' log_file|sort -k 2 -nr|head -n10"

带宽统计
cat apache.log |awk '{if($7~/GET/) count++}END{print "client_request="count}'

找出某天访问次数最多的10个IP
cat /tmp/access.log | grep "20/Mar/2011" |awk '{print $3}'|sort |uniq -c|sort -nr|head

当天ip连接数最高的ip都在干些什么
cat access.log | grep "10.0.21.17" | awk '{print $8}' | sort | uniq -c | sort -nr | head -n 10

小时单位里ip连接数最多的10个时段
awk -vFS="[:]" '{gsub("-.*","",$1);num[$2" "$1]++}END{for(i in num)print i,num[i]}' log_file | sort -n -k 3 -r | head -10

找出访问次数最多的几个分钟
awk '{print $1}' access.log | grep "20/Mar/2011" |cut -c 14-18|sort|uniq -c|sort -nr|head

取5分钟日志
if [ $DATE_MINUTE != $DATE_END_MINUTE ] ;then 
#则判断开始时间戳与结束时间戳是否相等
START_LINE=sed -n "/$DATE_MINUTE/=" $APACHE_LOG|head -n1 #如果不相等，则取出开始时间戳的行号，与结束时间戳的行号

查看tcp的链接状态
netstat -nat |awk '{print $6}'|sort|uniq -c|sort -rn 
netstat -n | awk '/^tcp/ {++S[$NF]};END {for(a in S) print a, S[a]}' 
netstat -n | awk '/^tcp/ {++state[$NF]}; END {for(key in state) print key,"\t",state[key]}' 
netstat -n | awk '/^tcp/ {++arr[$NF]};END {for(k in arr) print k,"\t",arr[k]}' 
netstat -n |awk '/^tcp/ {print $NF}'|sort|uniq -c|sort -rn 
netstat -ant | awk '{print $NF}' | grep -v '[a-z]' | sort | uniq -c
netstat -ant|awk '/ip:80/{split($5,ip,":");++S[ip[1]]}END{for (a in S) print S[a],a}' |sort -n 
netstat -ant|awk '/:80/{split($5,ip,":");++S[ip[1]]}END{for (a in S) print S[a],a}' |sort -rn|head -n 10 
awk 'BEGIN{printf ("http_code\tcount_num\n")}{COUNT[$10]++}END{for (a in COUNT) printf a"\t\t"COUNT[a]"\n"}'

查找请求数前20个IP（常用于查找攻来源）：
netstat -anlp|grep 80|grep tcp|awk '{print $5}'|awk -F: '{print $1}'|sort|uniq -c|sort -nr|head -n20 
netstat -ant |awk '/:80/{split($5,ip,":");++A[ip[1]]}END{for(i in A) print A[i],i}' |sort -rn|head -n20

用tcpdump嗅探80端口的访问看看谁最高
tcpdump -i eth0 -tnn dst port 80 -c 1000 | awk -F"." '{print $1"."$2"."$3"."$4}' | sort | uniq -c | sort -nr |head -20

查找较多time_wait连接
netstat -n|grep TIME_WAIT|awk '{print $5}'|sort|uniq -c|sort -rn|head -n20

找查较多的SYN连接
netstat -an | grep SYN | awk '{print $5}' | awk -F: '{print $1}' | sort | uniq -c | sort -nr | more

根据端口列进程
netstat -ntlp | grep 80 | awk '{print $7}' | cut -d/ -f1

查看了连接数和当前的连接数
netstat -ant | grep $ip:80 | wc -l 
netstat -ant | grep $ip:80 | grep EST | wc -l

查看IP访问次数
netstat -nat|grep ":80"|awk '{print $5}' |awk -F: '{print $1}' | sort| uniq -c|sort -n

Linux命令分析当前的链接状况
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
watch "netstat -n | awk '/^tcp/ {++S[\$NF]} END {for(a in S) print a, S[a]}'" # 通过watch可以一直监控

LAST_ACK 5 #关闭一个TCP连接需要从两个方向上分别进行关闭，双方都是通过发送FIN来表示单方向数据的关闭，当通信双方发送了最后一个FIN的时候，发送方此时处于LAST_ACK状态，当发送方收到对方的确认（Fin的Ack确认）后才真正关闭整个TCP连接；

SYN_RECV 30 # 表示正在等待处理的请求数；

ESTABLISHED 1597 # 表示正常数据传输状态；

FIN_WAIT1 51 # 表示server端主动要求关闭tcp连接；

FIN_WAIT2 504 # 表示客户端中断连接；

TIME_WAIT 1057 # 表示处理完毕，等待超时结束的请求数；

1、查找目录下所有以 .zip 结尾的文件移动到指定目录。
find . -name "*.zip" -exec mv {} ./backup/ \;
2、查找当前目录 30 天以前大于 100M 的 log 文件并删除。
find . -name "*.log" –mtime +30 –typef –size +100M | xargs rm –rf {};
3、批量解压当前目录下以 .zip 结尾的所有文件到指定目录。

for i  in  `find . –name "*.zip" –type f`
do
  unzip –d $i /data/www/
done
注解：for i in （command）;do … done 为 for 循环的一个常用格式，其中i为变量，可以自己指定。

4、写一个脚本查找最后创建时间是 3 天前，后缀是 *.log 的文件并删除。

find . -mtime +3  -name "*.log" | xargs rm -rf {};
5、写一个脚本将某目录下大于 100k 的文件移动至 /tmp 下

find . -size +100k -exec mv {} /tmp;
6、如何判断某个目录是否存在，不存在则新建，存在则打印信息。

if [ ! –d /data/backup/ ];then
   mkdir –p /data/backup/
else
echo  "目录已存在"
fi
-d 代表目录

7、替换文件中的目录

sed 's:/usr/local:/tmp:g' test.txt
或者
sed -i 's//usr/local//tmp/g' test.txt
8、sed 常用命令

如何去掉行首的.字符: sed -i 's/^.//g' test.txt

在行首添加一个a字符: sed 's/^/a/g'    test.txt

在行尾添加一个a字符: sed 's/$/a/'     tets.txt

在特定行后添加一个z字符：sed '/rumen/az' test.txt

在行前加入一个c字符: sed '/rumenz/ic' test.txt
9、sed 另外一个用法找到当前行，然后在修改该行后面的参数

sed -i '/SELINUX/s/enforcing/disabled/' /etc/selinux/config
sed 冒号方式

sed -i 's:/tmp:/tmp/abc/:g' test.txt意思是将/tmp改成/tmp/abc/。
10、统计 Nginx 访问日志 访问量排在前20的ip地址

cat access.log |awk '{print $1}'|sort|uniq -c |sort -nr |head -20
注解：sort 排序、uniq（检查及删除文本文件中重复出现的行列 ）

11、修改文本中以ab 结尾的替换成 cd：

sed -e 's/ab$/cd/g' b.txt
12、网络抓包：tcpdump

#抓取 56.7 通过80端口请求的数据包。
tcpdump -nn host 192.168.56.7 and port 80
#排除0.22 80端口
tcpdump -nn host 192.168.56.7 or ! host 192.168.0.22 and port 80
13、统计 bash_history 最常用的 20 条命令

history | awk '{print $2}' | sort | uniq -c | sort -k1,1nr | head -10
14、配置防火墙脚本，只允许远程主机访问本机的 80 端口

iptables -F
iptables -X
iptables -A INPUT -p tcp --dport 80 -j accept
iptables -A INPUT -p tcp -j REJECT
或者
iptables -A INPUT -m state --state NEW-m tcp -p tcp --dport 80 -j ACCEPT
```

日志分析常用命令

## Redis脚本安装




```sh
#!/bin/bash
#
#********************************************************************
#Author:          zhangwei
#QQ:              200957079
#Date:            2020-07-02
#FileName：       install_redis.sh
#URL:             http://www.ztunan.top
#Description:     The test script
#Copyright (C):   2020 All rights reserved
#********************************************************************
REDIS_VERSION=redis-6.2.5
#REDIS_VERSION=redis-4.0.14
PASSWORD=123456
INSTALL_DIR=/apps/redis
CPUS=`lscpu |awk '/^CPU$s$/{print $2}'`

. /etc/os-release

color () {
    RES_COL=60
    MOVE_TO_COL="echo -en \\033[${RES_COL}G"
    SETCOLOR_SUCCESS="echo -en \\033[1;32m"
    SETCOLOR_FAILURE="echo -en \\033[1;31m"
    SETCOLOR_WARNING="echo -en \\033[1;33m"
    SETCOLOR_NORMAL="echo -en \E[0m"
    echo -n "$1" && $MOVE_TO_COL
    echo -n "["
    if [ $2 = "success" -o $2 = "0" ] ;then
        ${SETCOLOR_SUCCESS}
        echo -n $"  OK  "    
    elif [ $2 = "failure" -o $2 = "1"  ] ;then 
        ${SETCOLOR_FAILURE}
        echo -n $"FAILED"
    else
        ${SETCOLOR_WARNING}
        echo -n $"WARNING"
    fi
    ${SETCOLOR_NORMAL}
    echo -n "]"
    echo 
}


prepare(){
    if [ $ID = "centos" -o $ID = "rocky" ];then
        yum  -y install gcc make jemalloc-devel systemd-devel
    else
	    apt update 
	    apt -y install  gcc make libjemalloc-dev libsystemd-dev
    fi
    if [ $? -eq 0 ];then
        color "安装软件包成功"  0
    else
        color "安装软件包失败，请检查网络配置" 1
        exit
    fi
}
install() {   
    if [ ! -f ${REDIS_VERSION}.tar.gz ];then
        wget http://download.redis.io/releases/${REDIS_VERSION}.tar.gz || { color "Redis 源码下载失败" 1 ; exit; }
    fi
    tar xf ${REDIS_VERSION}.tar.gz -C /usr/local/src
    cd /usr/local/src/${REDIS_VERSION}
    make -j $CUPS USE_SYSTEMD=yes PREFIX=${INSTALL_DIR} install && color "Redis 编译安装完成" 0 || { color "Redis 编译安装失败" 1 ;exit ; }

    ln -s ${INSTALL_DIR}/bin/redis-*  /usr/bin/
    
    mkdir -p ${INSTALL_DIR}/{etc,log,data,run}
  
    cp redis.conf  ${INSTALL_DIR}/etc/

    sed -i -e 's/bind 127.0.0.1/bind 0.0.0.0/'  -e "/# requirepass/a requirepass $PASSWORD"  -e "/^dir .*/c dir ${INSTALL_DIR}/data/"  -e "/logfile .*/c logfile ${INSTALL_DIR}/log/redis-6379.log"  -e  "/^pidfile .*/c  pidfile ${INSTALL_DIR}/run/redis_6379.pid" ${INSTALL_DIR}/etc/redis.conf


    if id redis &> /dev/null ;then 
         color "Redis 用户已存在" 1 
    else
         useradd -r -s /sbin/nologin redis
         color "Redis 用户创建成功" 0
    fi

    chown -R redis.redis ${INSTALL_DIR}

    cat >> /etc/sysctl.conf <<EOF
net.core.somaxconn = 1024
vm.overcommit_memory = 1
EOF
    sysctl -p 
    if [ $ID = "centos" -o $ID = "rocky" ];then
        echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.d/rc.local
        chmod +x /etc/rc.d/rc.local
        /etc/rc.d/rc.local 
    else 
        echo -e '#!/bin/bash\necho never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local
        chmod +x /etc/rc.local
        /etc/rc.local
    fi


cat > /lib/systemd/system/redis.service <<EOF
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=${INSTALL_DIR}/bin/redis-server ${INSTALL_DIR}/etc/redis.conf --supervised systemd
ExecStop=/bin/kill -s QUIT \$MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
LimitNOFILE=1000000

[Install]
WantedBy=multi-user.target

EOF
     systemctl daemon-reload 
     systemctl enable --now  redis &> /dev/null 
     if [ $? -eq 0 ];then
         color "Redis 服务启动成功,Redis信息如下:"  0 
     else
         color "Redis 启动失败" 1 
         exit
     fi
     sleep 2
     redis-cli -a $PASSWORD INFO Server 2> /dev/null
}

prepare 
install 

```

Redis-脚本

# Redis数据库



## 一、redis数据库介绍
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

在6.0版本前，redis一直是使用单线程方式处理用户请求，单线程的好处：纯内存、非阻塞、避免静态消耗。

**注意：避免在redis中使用keys * 命令，这是导致redis变慢的原因之一，当然，也可在redis中禁用此命令。**

**相比于memcached，redis的持久化、高可用、存储容量等功能都比memcached好，但是redis的单机QPS和并发量比不上memcached。**
## 二、redis使用场景
- 缓存：缓存RDBMS中数据,比如网站的查询结果、商品信息、微博、新闻、消息
- Session 共享：实现Web集群中的多服务器间的session共享
- 计数器：商品访问排行榜、浏览数、粉丝数、关注、点赞、评论等和次数相关的数值统计场景
- 社交：朋友圈、共同好友、可能认识他们等
- 地理位置: 基于地理信息系统GIS（Geographic Information System)实现摇一摇、附近的人、外卖等   功能
- 消息队列：ELK等日志系统缓存、业务的订阅/发布系统
## 三、redis数据读取和写入流程
### 1、redis写入流程
比如后端数据库是mysql：先更新DB，然后直接删除redis的对应项。

![image.png](http://vanblog.ztunan.top/static/img/f1f58e5a82d2cad0d8f20acbc194e7ba.image.png)
### 2、redis读取流程
用户先从redis读取数据，读到了直接返回给用户。读不到就去后端mysql找数据，mysql中不论结果如何都会返回给用户并且写入redis。

![image.png](http://vanblog.ztunan.top/static/img/a118478ce1a97322f6ad23d0c5dcce3d.image.png)


# 四、redis安装

### 1、源安装

:::info{title="yum"}
rhel系列：    yum -y install redis
             systemctl enable --now redis
Ubuntu系统：  apt install redis      
             systemctl enable --now redis
:::
### 2、编译安装，这里简单介绍一下。还有一篇脚本安装的文章，直接下载下来运行即可
**编译安装三大步，但是redis编译安装很简单，只要make install就可以**
1. ./confiure
2. make
3. make install


:::note{title="redis包下载地址"}
http://download.redis.io/releases/
:::

```sh
#这里使用的环境是rocky8

#第一步、安装相关包
yum -y install gcc make jemalloc-devel

#第二步、下载源码包并解压
wget http://download.redis.io/releases/redis-6.2.4.tar.gz
tar xf redis-6.2.4.tar.gz
#第三步、进入解压目录，查看帮助、readme、install等文件，redis的INSTALL文件内容就是See readme，那就只能看readme了
cd redis.6.2.4
#查看帮助，文档里写的可以指定安装目录PREFIX选项，
cat README.md | grep install
installed):
In order to install Redis binaries into /usr/local/bin, just use:
    % make install
You can use `make PREFIX=/some/other/directory install` if you wish to use a
Make install will just install binaries in your system, but will not configure
needed if you just want to play a bit with Redis, but if you are installing it the proper way for a production system, we have a script that does this
for Ubuntu and Debian systems:
#第四步、安装，这里的-j 2表示使用使用计算机的两个CPU编译，加快速度
make -j 2 USE_SYSTEMD=yes PREFIX=/apps/redis install
#第五步、配置环境变量，准备相关目录和配置文件
echo 'PATH=/apps/redis/bin:$PATH' > /etc/profile.d/redis.sh
. /etc/profile.d/redis.sh
mkdir /apps/redis/{etc,log,data,run} #创建配置文件、日志、数据等目录
cp redis.conf /apps/redis/etc/
#第六步、启动
redis-server /apps/redis/etc/redis.conf #必须指定配置文件路径
#客户端连接使用redis-cli即可
```
# 五、配置文件详解

```sh
bind 0.0.0.0 #指定监听地址，支持用空格隔开的多个监听IP

protected-mode yes #redis3.2之后加入的新特性，在没有设置bind IP和密码的时候,redis只允许访问127.0.0.1:6379，可以远程连接，但当访问将提示警告信息并拒绝远程访问

port 6379 #监听端口,默认6379/tcp

tcp-backlog 511 #三次握手的时候server端收到client ack确认号之后的队列值，即全连接队列长度

timeout 0 #客户端和Redis服务端的连接超时时间，默认是0，表示永不超时

tcp-keepalive 300 #tcp 会话保持时间300s
daemonize no #默认no,即直接运行redis-server程序时,不作为守护进程运行，而是以前台方式运行，
如果想在后台运行需改成yes,当redis作为守护进程运行的时候，它会写一个 pid 到/var/run/redis.pid文件

supervised no #和OS相关参数，可设置通过upstart和systemd管理Redis守护进程，centos7后都使用systemd

pidfile /var/run/redis_6379.pid #pid文件路径,可以修改为/apps/redis/run/redis_6379.pid

loglevel notice #日志级别

logfile "/path/redis.log" #日志路径,示例:logfile "/apps/redis/log/redis_6379.log"

databases 16 #设置数据库数量，默认：0-15，共16个库

always-show-logo yes #在启动redis 时是否显示或在日志中记录记录redis的logo

save 900 1 #在900秒内有1个key内容发生更改,就执行快照机制

save 300 10 #在300秒内有10个key内容发生更改,就执行快照机制

save 60 10000  #60秒内如果有10000个key以上的变化，就自动快照备份

stop-writes-on-bgsave-error yes #默认为yes时,可能会因空间满等原因快照无法保存出错时，会禁止redis写入操作，生产建议为no

#此项只针对配置文件中的自动save有效
rdbcompression yes #持久化到RDB文件时，是否压缩，"yes"为压缩，"no"则反之

rdbchecksum yes #是否对备份文件开启RC64校验，默认是开启

dbfilename dump.rdb #快照文件名

dir ./ #快照文件保存路径，示例：dir "/apps/redis/data"
```