AI专业者开发社区 1 号成员
  •  0 回帖  •  8 浏览  •  5 个月前
   

25.liunx学习 

https://www.cnblogs.com/pyyu/artitles/9313587.html  linux安装
https://www.cnblogs.com/pyyu/p/9276851.html  linux命令学习大全
https://www.cnblogs.com/pyyu/p/9213237.html  Linux之文档与目录结构学习
https://www.cnblogs.com/pyyu/p/9314206.html  linuxShell基本命令学习
https://www.cnblogs.com/pyyu/p/9355477.html  linux用户管理
https://www.cnblogs.com/pyyu/articles/9365054.html  linux常用服务安装部署
https://www.cnblogs.com/pyyu/articles/9460649.html  linux vim使用
https://www.cnblogs.com/pyyu/p/9467289.html   mysql+centos7+主从复制

今日内容：

环境变量：

这个东西在linux中如何设置，说实话看了那么多博客，写的博客根本看不懂
windows很好改，每次启动的时候你的程序的时候第一个方法就是去环境变量中加，第二个办法就是在你的pycharm解释器中配置，网上很多自己看下

linux 中我们需要编辑 vim /etc/profile 文件 这个文件就是系统的环境变量文件
shift + g 直接跳到文件最后一个行，其实就是 G,g 是跳到第一行
然后再文件最后一行追加
export test="this is a test"  # 记得千万别再 = 之间加空格，找错都找不到
wq! 退出保存
source /etc/profile 其实可以理解为刷新环境变量，你改了文件，但是系统自启动的时候加载了一遍之后生成缓存，你改了就需要重新生成缓存，这个命令就是
vim test.py
import os
print(os.environ.get("TEST"))
wq!
python test.py  #执行文件就好了


很简单的东西，网上乱七八糟说一堆，没有重点。

端口：

端口概念：
0——65535
银行的端口，不同的端口对应不饿欧诺个的业务

8000 自定义的 django 端口 9000 8080 8001
3306 mysql
80 web 服务端口， 浏览器的默认找 80
443 https + http + ssl 加密技术，对 http 通信加密
6379 redis 默认端口
23 telnet
22 ssh 端口，我们远程连接的协议就是 ssh（远程加密传输协议）
远程连接服务器的知识：
ssh 命令，通过 ssh+ip+ 端口，找到我们的服务器，对应找到 22 端口的 ssh 协议


ipconfig 这是看 windows 的 ip
ip addr show 查看 linux 的 ip
通过 ssh 命令。通过 root 账户登录 192.168.13.98 这台机器
ssh root@192.168.13.98


在公司中也就是给你一个服务器的 ip，自己连接


linxu 的多个用户，多终端的概念


linux 的终端概念
termeinel


linux 有 7 个终端
f1-f7 f1 是图形化界面


远程终端：使用 ssh 进行连接


w：命令查看 linux 终端信息
xshell 3 个终端
vmware 2 个终端

用户 & 环境变量：

whoami: 查看当前用户
pwd:查看密码文件
linux节本命令：其实就是一堆英文缩写，使用linux系统的熟练度，就是看你命令掌握了多少
ip addr show
ls	查看linux文件夹信息 list缩写
	linux 白色的是普通文件；蓝色的是文件夹
cat 查看linux文件
cd change 目录 更改目录
touch 创建普通文本
touch ni test1 test2
mkdir 创建文件夹
pwd print work 目录   打印当前工作目录（我在那？）

vi linux 底下的文本编辑器 notepad++
1.vi 文件， 此时进入了一个命令模式，需要你输入 i 字母，插入指令
2. 在编辑器模式下，可以输入一堆字符串
3. 当代码写完了， 按下 esc 回到命令模式。按下： 输入 w q !
:wq! write 写去 quit 退出！强制退出
：q! 不保存退出


mv 移动指令 move
1. 移动文件、文件夹到别的目录
2. 改名 mv 旧名字 新名字


rm 删除 remove 指令   删除命令，在服务器上慎用


rm 文件名 删除文件的命令


rm 文件名 * 支持通配符


这是 mysql 默认数据文件


rm -rf /var/lib/mysql/*


环境变量


linux 环境变量 path
/opt/python36/bin/python3.6
在 linux 上安装 python3 的时候
echo "$PATH" 查看环境变量
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/python36/bin/python3.6:/opt/nginx/bin/niginx
当我们输入 python3.6 的时候，他会按照顺序，自上而下查找


linux 的绝对路径，相对路劲


只要从根目录开始的查找，就是绝对路径
不是从根目录开始的都是相对路径
# mkdir -p /tmp/temp  -p 地轨创建
# [root@localhost ~]#   用户身份提示符
用户名  主机名  工作目录
# useradd  xiaoming 创建用户
# passwd   1234    创建密码
普通用户是 $ ,root 用户是#


用户修改密码


file /usr/bin/passwd   查看这个文件的类型
ll /etc/shadow /usr/bin/passwd  查看用对这两个文件的权限
/usr/bin/passwd   可以修改当前用户的密码


# echo "woshishui" > ../../test.text  将内容写入文件
python with open
w 覆盖写入
a 追加写入
# > 重定向输出符
# >> 重定向追加输出符
# << 重定向写入符
# cat ../../test.text -n  查看文本内容， -n 换行
# cat >> kun.txt << EOF
adfsafsdf
EOF   必须使用这个结束

vi/vim:

# 文件
vi 相当于记事本 不好用
vim  支持编程的记事本编辑器， notepad++
vim filename.txt 进入命令行模式后，可以输入各种命令
set nu 显示行号
yy 复制   n yy  复制下面的n行
dd 删除   n dd  删除下面的n行
G  跳转到文件尾部：
gg 跳转到文件开始
o 下一行
x 删除光标所在的字符
在脚本文件的第一行会被认为是，帮助文档。
cat 看多之后全部输出，不适合长文本
more 查看长文本， b上翻页， 空格下翻
linux的man手册 查看命令的帮助

d G   进入文本之后直接输入这个会删除真个文本

cp:

# 拷贝移动
cp settiongs.py settings.bak 拷贝文件  -r递归拷贝，目录
cp 要拷贝的文件  输出的文件
mv settiongs.py old.py   移动,改名

find：

# 查找文件命令
everything window找文件的app
find / -name settings.py   
find / -type f -name *.py
find 从哪找 找什么
# 管道命令 |  可以将命令一的结果给命令二执行
grep "STA"  settings.py
cat settiongs.py | grep "STA"  查找STA开头的内容，并显示
grep -v "STA*" settings -n   查找除了STA开头的内容，并显示行号
# head命令
head -2 t.sh 查看头两行， 不写-2默认前十行
# tail命令
tail -2 t.sh 查看后两行， 不写-2默认后十行
tail -f settings.py  -f 动态监听，可以查看实时写入数据

alias:

# dns 是什么? bind
/etc/hosts   本地dns解析文件
www.s15baidu.com  192.168.121.11
# alias  别名命令
alias rm='rm -i'   当你输入了rm的时候就等于输入了rm -i
alias rm=rm   改变命令别名，十分恐怖，有人改了这个你不知道，直接把库删了，就完了
unalias rm   取消这个快捷方式
alias rm="echo 不能使用rm"
docker devops 运维开发，敏捷开发
# which   rm  输出rm命令的根目录
# whereis rm  输出rm可能出现的所有目录
# who  查看登录过得用户  w 也可以

scp:

# 远程传输
scp root@172.20.163.39:/tmp/yuan.txt /opt/  将远程文件传输到本地172.20.163.39的opt目录下
scp t.sh root@172.20.163.39:/opt/    传入文件t.sh到远程172.20.163.39

查看文件大小：

# 查看文件大小
ls -lh 查看文件大小
du -h  查看文件大小
du -sh /var/log 统计log文件的总大小

top:

# 进程
top 动态查看进程
free -m  查看硬盘的大小


# 加锁
chattr +a t.sh  加锁
lsattr t.sh  查看文件隐藏属性
chattr -a t.sh  去锁


# 查看时间
date  查看时间
ntpdate -u ntp.aliyun.com  同步时间

wget:

# 爬虫
wget 地址  下载资源命令


# window 和 linux 传入文件的东西
yun install lrzsz -y


reboot命令用于重启机器
poweroff用于关闭系统


开发 
运维
运维开发
熟悉python OOP编程
熟悉linux环境编程（centos.redhat 7）
熟悉部署python程序通过niginx+uwsigi+virtualenv+supervirso
熟悉mysql curd 主从同步，权限分配
熟悉redis curd redis主从数据同步，RDB，AOF数据持久化
熟悉niginx部署多虚拟主机，反向代理，负载均衡
熟悉docker使用，构建dockerfile编写镜像，搭建私有docker仓库
熟悉saltstack运维管理软件使用
熟悉ubantu

今日内容：

https://www.cnblogs.com/pyyu/p/9355477.html

ifconfig 查询，设置网卡和ip参数
ifup ens33  启动网卡
idown 关闭网卡
systemctl restart/start/stop newwork  网卡网络


useradd  用户名  存放用户信息到/etc/passwd
passwd  用户名 设置修改，密码， 如果不指定用户，默认当前用户

id:

id root  查看root用户的uid和ugroup
/etc/passwd 存放用户信息 
/etc/group  存放用户组
# 通过id命令查看用户信息

root 用户切换普通用户不需要密码，普通用户切换 root 用户需要知道密码
# 切换用户身份
su  - xiaoming  切换用户  中间的 - 代表连同环境也切换


xshell 快捷键
ctrl +l 清屏
ctrl +d 退出登录
ctrl + shift + r 快速登录

userdel:

# 修改命令提示符，添加绝对路劲，和时间
$PS1="[\u@\h \w \t]\$"

# groupadd 命令  用户组添加
groupadd 用户名

# 删除用户
userdel xiaobao  未删除家目录

grep xiaobai /etc/passwd


userdel -rf xiaobai  直接强制删除用户，包括家目录

sudo：

# /etc/sudoers
sudo命令用来以其他身份来执行命令，预设的身份为root。在/etc/sudoers中设置了可执行sudo指令的用户。若其未经授权的用户企图使用sudo，则会发出警告的邮件给管理员。用户使用sudo时，必须先输入密码，之后有5分钟的有效期限，超过期限则必须重新输入密码。
当权限不够的时候去/etc/sudoers 将自己的用户加上，就可以了
sudo ls /etc/passwd

用 root 身份去执行命令 sudo
编辑这个文件，写入一些配置 vi /etc/sudoers
找到这一行配置


ALLOW ROOT TO RUN ANY COMMADND ASYWHERE


root   all=(all)     all
xiaoming   all=(all)   all


visudo 命令，提供语法检测，写错之后会提供提示


修改主机名：


hostnamectl set-hostname s15nb
重新登陆就改了

文件目录权限：

# 显示所有文件
ls -la
drwxr-xr-x.  3        root    root    18       Dec 13 23:54    .cache
drwxr-xr-x.  3        root    root    18       Dec 13 23:54    .config
权限类型     软连接数   用户    组     文件大小    日期           文件名

user/owner 文件使用者, 文件属于哪个用户
group 属组, 文件属于哪个组
others 既不是 user，也不再 group，就是 other，其他人


文件夹的权限：


d   rwx              r-x                r-x
root 这个用户     属于 root 组里的      既不是 root 用户，又不在 root 组的权限
d 代表文件夹


    

  • 代表普通文件
    • 



r 可读
w write 可写
x 可执行


-rw-r--r--. 1 root root 72 Dec 18 18:15 t.sh
这个文件属主 root
属组 root
是什么类型文件  是  -  普通文件
权限是什么  rw-r--r--
这个文件的属主的权限是 rw-
这个文件的属组的权限是 r--
其他用户的权限是 r--
# 	
对于普通文件的可读可写可执行
可读 cat vi more less head tail tac
可写 echo vi  >  重定向符号
可执行  二进制文件，可运行的程序

#
r 可以对目录执行ls列出所有文件
w 可以在这个目录创建文件
x 可以 cd 进入这个目录，或者查看详细信息




文件创建时间 Dec 18 18:15
文件大小 72


修改文件的权限


r 4
w 2
x 1
sudo chomd 777 t.sh


更改属主


chown xiaoming t.sh


更改组


chgrp xiaoming t.sh


-rw-r--r--
普通文件，root 可读可写，group 可读，others 可读


id  查看自己的分组


# chmod o+w  t.sh

软连接：

# ln命令
ln -s 目标文件绝对地址 快捷方式的绝对路劲
sudo ls -s /home/xiaoming/a.txt /home/a.txt

py3 /opt/python36/bin/python3.6
python 的时候，就去 path 中去找


将 python3.6 的解释器，添加快捷方式到 /usr/local/sbin/python3.6


# 当我们输入 python 的时候
ln -s /opt/python36/bin/python3.6  /usr/local/sbin/


软连接和 path 添加二选一，即可，都添加会出现问题


echo $PATH
PATH 变量只能添加目录，不能添加到指定文件
将某个文件县的所有内容，都加入环境变量
/usr/local/bin:/bin
:/usr/bin:/usr/local/sbin
:/usr/sbin
:/home/xiaoming/.local/bin
:/home/xiaoming/bin
# 假设不适用这个
：/opt/python36/bin  这才是正确的添加 python 环境变量方式

压缩：

# tar 压缩解压命令
lrzsz  上传下载小工具
xftp  文件传输工具

tar 命令
-c 压缩参数
-x 解压参数
-v 显示过程
-f 指定文件    这个参数写在最后


语法：
# 压缩文件
tar -cf 压缩文件名  想压缩的内容
# 解压文件
tar -xf 压缩文件名
# gzip 压缩

网络端口：

# django 运行之后，会咋么样？
开通一个端口 8000
等待连接
产生一个进程
产生日志
可能出现一堆大黄页

linux 一个程序运行后
# 进程查看
ps -ef | grep  22 查看任务是否运行有进程
# 端口查看
netstat -tunlp | grep  查看任务的端口号是否启动
# 
来自同一台机器的三个 ip
0.0.0.0  127.0.0.1 和 172.20.22.12；暴露应用又在对外的 ip 地址，又暴露在自己的回环地址
127.0.0.1  本地回环地址，代表机器自己的内部一个 ip，其他人访问不到，并且每个人都有自己 127.0.0.1
172.20.22.12  本地对外可以提供访问的 ip 地址，每个人都不一样
# 
python manage.py runserver 启动 django
python manage.py runserver  172.20.22.12：8000 在 172.20.22.12 地址上启动 800 端口提供访问
其他人访问地址 172.20.22.12：8000
# 
python manage.py runserver 默认启动在 127.0.0.1：8000
其他人访问不到你的项目
# 
python manage.py runserver  0.0.0.0:8000
其他人可以访问，你的 ip+ 端口就可以了
#
如果您没有 ifconfig
输入这个命令，安装一个：yum install net-tools -y
# 如果你发现你没有命令，在确保你没有敲错代码的情况下，就是没有安装这个命令
在你装机的时候，最小化安装包，可能只有 500 个软件
选择 web 服务软件安装，1000 个软件
如果缺少命令，不要怕，缺啥就安装啥


yum 这个软件管理命令安装

进程 ps：

ps 命令用于查看系统中的进程状态，格式为ps [参数]
ps　　命令常用参数
-a     显示所有进程
-u     用户以及其他详细信息
-x    显示没有控制终端的进程
ps -ef 
ps -aux  两个命令差不多，下面全一些
# 杀死进程
kill 进程号（PID）
#  查询
ps -ef | grep python 显示python相关的进程
root       1042      1  0 17:34 ?        00:00:01 /usr/bin/python2 -Es /usr/sbin/tuned -l -P
xiaoming   1779   1451  0 19:58 pts/0    00:00:00 python python.py
xiaoming   1832   1785  0 19:59 pts/1    00:00:00 grep --color=auto python
# kill 命令， 如果你kill一个进程，死活杀不死，就加上 -9   
-9 强制杀死进程，以及相关的依赖（为什么杀不死就是因为其他东西在用）
kill -9 mysql
kill -9 redis

防火墙：

https://blog.csdn.net/qq_41453285/article/details/88539523

# selinux 内置的防火墙
# 查询 selinux 状态
getenforce
# 暂时停止 selinux
setenforce 0
# 永久关闭
vi /etc/selinux/config
#     enforcing - SELinux security policy is enforced.   开启
#     permissive - SELinux prints warnings instead of enforcing.   临时关闭
#     disabled - No SELinux policy is loaded.   永久关闭
修改如下行
SELINUX=enforcing
重启机器，使得selinux永久关闭

# 软件防火墙
iptables -F  清空规则
iptables -L   查看规则
查看iptables防火墙规则，看到只有如下三个，就说明，没有规则了
关闭防火墙需求，防止他影响你的其他服务访问
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination


Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination


停止防火墙服务


systemtcl start/restart/stop firewalld
# 删除 iptables 的开机自启动
systentcl disable firewalld
# sestatus 查看相信信息
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted  # 名称
Current mode:                   permissive  # 模式，如果使用 getenforce 获取到的模式是 enforing（强制模式）呢就赶紧改到 permissive(宽容模式), 强制模式会导致一些进程出现问题，比如 ssh 使用 xshell 连接不上，我就遇到了。
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Max kernel policy version:      31

字符编码：

# linux 的字符编码：
# 查看字符编码：
echo $LANG
# 修改 linux 的字符编码
1.编辑字符编码的文件
/etc/locale.conf
写入如下变量
LANG=zh_CN.UTF-8
2.读取这个文件，使得变量生效
source  读取命令
source /etc/locale.conf   
3.查看系统字符编码

df 显示磁盘分区可用空间：

df -h 查看磁盘空间命令

tree:

tree ./  当前目录树状结构

如果没有的话就 yum install tree -y

grep:

grep命令  是一个过滤命令
- v  取反
grep "^#"  redis.conf   显示redis.conf 文件 所有的注释行
grep -v  "^#"  redis.conf   显示redis.conf 文件 所有的非注释行
grep -v  "^#"  redis.conf | grep -v "^$"  同时去掉空行，里面是正则匹配

sed 替换:

sed 's/xiaoming/make/g'  name.conf   将name.conf文件中的xiaoming全部替换成make

> & >>

> 覆盖写入     类似 python 稳健操作中的 w 模式
>> 追加写入    类似 python 稳健操作中的 a 模式
touch a.txt
[xiaoming@localhost ~]$ echo "hello" > a.txt 
[xiaoming@localhost ~]$ cat a.txt 
hello
[xiaoming@localhost ~]$ echo "hello" >> a.txt 
[xiaoming@localhost ~]$ 
[xiaoming@localhost ~]$ cat a.txt 
hello
hello
[xiaoming@localhost ~]$ echo "hello" > a.txt 
[xiaoming@localhost ~]$ cat a.txt 
hello

kill&pkill:

kill  进程号
pkill  进程最后面的名字

dns：

bind软件，配置dns服务的
常见的互联网 dns服务器
8.8.8.8 谷歌
114.114.114.114  114dns服务器地址
223.6.6.6 阿里巴巴的dns服务器地址
119.29.29.29  腾讯

# linux dns 配置文件 /etc/resolv.conf
[xiaoming@localhost ~]$ cat /etc/resolv.conf
# Generated by NetworkManger
nameserver 119.29.29.29  主dns
nameserver 233.5.5.5  备用dns

# /etc/hosts 文件 本地 dns 强制解析的文件
[root@localhost /]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
119.29.29.29 www.baidu.com

# dns 解析顺序
1./etc/hosts
2./etc/resolv.conf

linux 用于解析域名的命令
# nslookup

定时任务：

crontab  -l  查看定时任务
crontab  -e 编辑定时任务
crontab  -r  删除定时任务

在 /etc 目录下有一个 crontab 文件，这个就是系统任务调度的配置文件
vim /etc/crontab
[root@localhost /]# cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root


For details see man 4 crontabs


# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# |  |  |  |  |
# *  *  *  *  * user-name  command to be executed
分 时 日 月 周

# crontab 的语法：
crontab （选项）（参数）
-e：编辑该用户的计时器设置；
-l：列出该用户的计时器设置；
-r：删除该用户的计时器设置；
-u<用户名称>：指定要设定计时器的用户名称。

1 查看计划任务的执行：tail -f /var/log/cron
2 写计划任务时，命令必须加上绝对路径，否则会出现这种情况：从日志中看，确实触发了计划任务的执行，但是命令却没有执行成功，比如 * * * * * reboot 就会出现这种情况，需要将 reboot 写成 /usr/sbin/reboot
3.  计划任务执行的命令 是否存在，软件是否安装
4. 确保 crontab 服务运行


    

  • 

      

    • 

        

      • 

          

        • 

            

          • /usr/bin/echo "你好" >> /home/a.txt    必须使用绝对路劲
            • 

          

          • 

        

        • 

      

      • 

    

    • 



# 作业
所有命令一定要用绝对路径来写！
#每分钟执行一次命令
* * * * * 命令
#每小时的 3,15 分组执行命令
3,15 * * * * 命令
#在上午 8-11 点的第 3 和第 15 分钟执行
3,15 8-11 * * * 命令
#每晚 21:30 执行命令
30 21 * * * 命令
#没周六、日的 1：30 执行命令
30 1 * * 6,0 命令
#每周一到周五的凌晨 1 点，清空 /tmp 目录的所有文件
0 1 * * 1-5 /usr/bin/rm -rf /tmp/*
#每晚的 21:30 重启 nginx
30 21 * * * /opt/nginx/sbin/nginx -s reload
#每月的 1,10,22 日的 4:45 重启 nginx
45 4 1,1,10,22 * * /opt/nginx/sbin/nginx -s reload
#每个星期一的上午 8 点到 11 点的第 3 和 15 分钟执行命令
3,15 8-11 * * 1 command

linux 软件包管理：

window软件包
	.exe可执行格式
	msi可执行安装文件
	.zip 压缩格式
	.rar 压缩格式
linux  软件包管理
linux 软件格式分为

1. 源码包格式
1. 下载 python3 的源码包
2. 解压缩源码包，切换目录
3. 编译且安装
4. 配置环境变量
5. 使用 python3
2.rpm 二进制包格式
1. 下载软件的 rpm 格式包
2.rpm -ivh lrzsz
3. 使用 lrzsz 工具


补充：
1.如果直接安装mysql15.6 rpm。依赖了很多的其他的软件包，我们得手动解决依赖
2.所以rpm安装方式，需要手动解决依赖关系，很麻烦，不建议使用



lrzsz 这是软件包的名字
提供的命令是
rz 接收文件
sz 发送文件


3.yum 安装方式
yum 工具，自定搜索下载 rpm 包，且安装，且解决依赖关系，自动处理下载其他的依赖 rpm 包


软件开发目录规范


lib 库文件
core 核心文件
bin 可执行文件
log 日志文件
readme 使用说明


和使用 python 的模块
pip3 install -i http://pypi.douban.com/simple flask


使用 linux 的软件，yum 默认区 centos 官网去下载


yun istall
yum 源的仓库路径在：
/etc/yum.repos.d/
这个目录地下，只有以.repo 结尾的文件，才会被识别为 yum 仓库


配置国内的 yum 源


1. 在 /etc/yum.repos.d/ 目录地下，定制我们自己的 repo 的仓库
2. 我们自己没有 yum 仓库，去找阿里巴巴的 yum 仓库
3.https://developer.aliyun.com/mirror  阿里巴巴的镜像站
4. 下载阿里巴巴的 yum 仓库文件
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget 下载文件之后，-O 参数 ，指定放到某个目录下，且改名
5. 清楚 yum 缓存  yum clean all
6. 生成新的 yum 缓存  yum makecache


发现 centos 的镜像源没有一些软件，额外配置一个仓库，里面入了很多第三方的软件，例如 mysyl，redis，niginx


1. 在配置 epel 额外的仓库
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
2. 最好在生成 yum 缓存
yum makecache
3. 随心所欲的使用 yum 工具


yum 实例用法


yum 安装 nginx web  服务器软件
1.yum install niginx -y     -y 一路都是 yes
2. 启动 niginx
直接输入 niginx
3. 修改 nginx 主页面，文件名字叫做 index.html
find / -name index.html  查找文件所在地
修改 这个 index.html 随意显示一句话


系统服务管理命令
只用通过 yum 安装的软件，默认才能使用这个命令管理器


systemtcl stop/restart/start nginx   关闭服务进程
kill  进程号

作业：

作业：
1.Linux下的uid、gid是什么？
	id 用户名   查看用户的id身份
	uid： 用户id，用来表示每一个用户的唯一标识
	gid： 组id，用来表示每一个用户组的唯一标识
2.如何切换用户？
	su - xiaoming
3. 创建删除用户   在/etc/passwd文件下
	创建：useradd 用户名  passwd 用户名 
	删除：userdel 用户名   删除用户记录  从/etc/passwd文件下
		 userdel -rf 用户名  强制删除用户及其家目录
4.怎么使用root身份执行命令
	编辑/etc/sudoers
	visude 可以直接修改，检测语法
	前面加上sudo，如果不管用就去修改/etc/sudoers文件
	sudo ls t.sh
5.linxu文件权限有哪些？
	r:可读  4
	w:可写  2 
	x:可执行  1
	-:没有权限  0
6.请说出755,740分别是什么权限？
	755： 属主rwx:可读可写可执行， 属组： r-x: 可读，可执行， 其他用户： r-x: 可读，可执行，
	740： 属主rwx:可读可写可执行， 属组： r--: 可读， 其他用户： ---: 无任何权限
7.修改文件权限只有属主可读可写可执行
	chmod u+r u+w u+x  t.sh
8.如何修改文件的属主和属组
	属主：chown xiaoming（用户名）  t.sh    
	属组：chgrp xiaoming（组名） t.sh
9.请解压oldboy.tar.gz
	oldboy.
	tar.gz 这个文件有两层压缩后缀，一个是tar一个是gzip
	我们得一层一层的解压，先去掉.gz后缀，在去掉.tar后缀
	tar -zxf oldboy.tar.gz
	-xf 解压

-x  解压
-f 指定某个压缩文件
-z 就是调用gzip去解压文件
-c 压缩
-C 制定解压的目录

tar -cf   ./test/a.tar  a.txt     将当前目录下的a.txt压缩到，test目录下，名字是a.tar
tar -xf   a.tar  -C /home/       将a.tar解压内容，放入/home/目录下



10. 压缩 /tmp/ 下的所有内容 oldbody.tar.gz
tar -zcf oldbody.tar.gz tmp/*
11. 如何查看 linux 端口号？
netstat -tunlp |grep 端口号
12. 如何杀死进程号 8888
kill 8888 or kill -9 8888
13. 如何关闭 iptables?
systenctl          stop firewalld
系统服务管理命令
disable   禁用
14. 查看 linux 的 dns 文件？
cat /etc/resolv.conf
15.linux 解析 dns 的命令是什么？
nslookup
16. 写一个定时任务，每周 3 的凌晨 1 点，压缩 /var/log/ 下的所有文件为 log.tar.gz？
crontab -l 查看定时任务
crontab -e 编写定时任务
crontab -r 删除定时任务
在 /etc 目录下有一个 crontab 文件，这个就是系统任务调度的配置文件
vim /etc/crontab   编辑编写的定时任务
0 1 * * 3  /usr/bin/tar -zcf log.tar.gz /var/log/*
17. 如何安装 mysql-5.6.rpm?
rpm -ivh mysql-5.6.rpm
yum install mysql-5.6.rpm -y
18. 如何安装 nginx?
yum install nginx -y
启动：nginx
关闭：systemctl stop nginx
19. 如何配置 yum epel 源, 用文字描述？
epel 源是干什么的？
仓库：第三方包的仓库，存放的是 rpm 格式的软件包
1. 备份 yum 源？
mkdir repo_dir
mv .repo repo_dir
2. 下载阿里云 repo 文件。
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
3. 清楚缓存和再次缓存
yum clean all
yum makecache
便于日后 yum 生成新的 yun 缓存
4. 扩展软件源
yum install -y epel-release
20.centos7 用什么命令管理服务？
systemctl restart/start/stop
centos6 用的是 service 系统服务管理命令
21. 如何给 linux 添加一个 dns 服务器记录？
vi /etc/resolv/conf
添加一个
nameserver x.x.x.x
	
# 错了
vim /etc/hosts   强制解析本地的 dns 服务，自己和自己玩
添加 ip   域名
22. 每个月 5，15, 25 的晚上 5 点 50 分重启 niginx?
50 17 5,15,25 * *  /usr/bin/systemctl restart nginx
50 17 5,15,25 * *  /usr/bin/nginx -s reload
23. 每周 3 到周 5 的深夜 11 点，备份 /var/log/ 到 vmtp/?
0 23 * * 3-5 /usr/bin/cp -r /var/log/  /vmtp/    # -r 递归拷贝
24. 每天早上 6.30 清空 /tmp/ 内容？
30 6 * * * /usr/bin/rm -rf /tmp/*
25. 每个星期三的下午 6 点到 8 点的第 5,15 分钟执行命令 command?
5,15 18-20 * * 3 /usr/bin/command
26. 查看 mysql 的端口状态？
netstat -tunlp | grep mysql
vim /etc/my.cnf   编辑 mysql 的配置文件
27. 如何查看 nginx 的进程？
ps -aux | grep nginx
28. 如何杀死 nginx 进程？
systemctl stop nginx
kill -9 nginx 的 pid

path:

系统的环境变量配置文件
 vim /etc/profile
 # linux 有一个全局个人配置文件  /etc/profile
            将PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/python36/bin/
            加入到这个文件的最后一行即可
source /etc/profile

今日内容：

1. 编译安装 python3

https://www.cnblogs.com/pyyu/articles/9365054.html

- 下载python3源码包
cd opt
wget https://www.python.org/ftp/python/3.6.2/Python-3.6.2.tgz
    # 如果没有 wget 则 yum install wget -y
	1.安装python前的库环境，非常重要
	通过yum 安装工具包，自动处理依赖关系，每个软件通过空格分隔
	# 提前安装工具包，以后就少了很多莫名其秒的报错
	yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel -y
- 解压缩源码包
	下载好python3源码包之后
	python-3.6.taz
	解压缩
	tar命令可以解压缩tgz格式
	tar -xvf python-3.6.tgz
- 切换源码包目录
	cd python-3.6
- 编译且安装
	1.释放编译文件makefile，这个makefile就是用来编译且安装的
        ./configure --perfix=/opt/python36/
         -- perfix 指定软件的安装目录
    2.开始编译python3
      	make
    3.编译且安装(之一在这一步，才会生成/opt/python36/)
    	make install 
    4.配置环境变量
    	1.配置软连接,其实解释windows的快捷方式
        	# 将 python3.6 的解释器，添加快捷方式到 /usr/local/sbin/python3.6
            # 当我们输入 python 的时候
            # ln -s 目标文件（就是我们自己的程序） 软连接文件（就是你把软连接放到哪里）理解为 windows 可以是， -s 后的第一个参数是实际的.exe 文件， 第二个参数就是我们把快捷方式创建到哪里，比如：桌面上
            ln -s /opt/python36/bin/python3.6  /usr/local/sbin/
        2.配置环境变量(PACH)二选一即可
            echo $PATH 查看环境变量
            /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
            加上自己的python bin目录，但是这个变量操作符，只是临时的，须要写入文件中，永久生效
            PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/python36/bin/
            # linux 有一个全局个人配置文件  /etc/profile
            将PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/python36/bin/
            加入到这个文件的最后一行即可
            # source /etc/profile
		3.下载django
        	pip3 install -i https://www.pypi.douban.com/dimple django
            # 这个时候可能会装不上，是因为 linux 的内置防火墙问题，输入下面的命令临时关闭
		   # selinux 内置的防火墙
            # 暂时停止 selinux
			setenforce 0
        4.新建django项目
        	django-admin startproject mysite
            cd mysite
            python manage.py runserver 0.0.0.0 :8000 启动
            # 这个时候使用 window 浏览器访问的时候还是会出现问题，因为 settings 中的 ALLOW_HOSTS=【*】没有配置 
            vim /opt/python36/settings  修改
            # 新建 app
            django-admin startapp app01 or python manage.py startapp

    <span class="hljs-number">5.</span>tree mysite/ 查看django项目目录结构        
       yum install tree -y
    <span class="hljs-number">6.</span>查找django文件    
        find / django



如果你的 yum 命令，提示 yum 进程被锁定，无法使用
解决办法：ps -ef | grep yum 进程，这是首有另一个进程在使用域名
yum 是单进程的，不能再下载其他的东西的时候使用，yum 只能有一个


python
吞吐量
django 600
flask  1000+
tornado  异步非阻塞的框架 1800+
sanic 2800+ uvlopp 事件驱动 用在游戏接口领域


go
net/http web 服务器 6W+

2.python 的虚拟环境 virtralenv

1.需求在linux服务器上，既可以有django2.0环境，也能运行django1.11环境
思路：
	1.django2.0想要运行，我们得准备python解释器+pip3软件包管理
	2.还想运行django1.11,python解释器+pip3
		- 再安装一个python3.6？？？？？
		- pip3 安装的模块，都放在哪里/opt/python36/lib/python3.6/site-package
	virtualenv 就是一个虚拟解释器
	基于物理环境下的python解释器，虚拟/分身出的多个解释器
2.安装virtualenv
  	pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv
  	安装完成之后就多出一个virtualenv命令
3.创建独立运行环境-命名
    mkdir myenv
    cd myenv
    virtualenv --no-site-packages --python=python3  venv #得到独立第三方包的环境，并且指定解释器是 python3
    # --no-site-packages 这是构建干净，隔离的模块参数
    # --python=python3  这个参数是指定虚拟环境以哪个物理解释器为基础的
    # venv 这个可以随便起名，就是你创建的虚拟环境的名称
4.激活虚拟环境source
	进入你的虚拟环境的bin目录中，找到这个虚拟环境的actinvate文件
	第三步执行完成之后会出现一个venv/bin文件夹，里面有activate
    # 激活虚拟环境，原理就是修改 PATH 变量，path 是有顺序执行的
    echo $PATH
    which python3
    which pip3  检查虚拟环境是否正常

source activate  <span class="hljs-comment"># 激活虚拟环境</span>
deactivate  <span class="hljs-comment"># 退出虚拟环境</span>



5.测试安装两个虚拟幻境，venv1，venv2, 并运行2个 djagno 不同版本的项目


6.虚拟与物理对比
# 这个时候 pip list 查看安装过的包发现虚拟环境很干净
# 这个时候可以创建多个虚拟环境，每个虚拟环境使用不同的 django 版本创建项目
7.装包
保证本地开发环境和线上一样的
1.到处当前线上的包
pip3 freeze > requirements.txt
他会将当前虚拟环境的安装的包生成一个文件
2.将 requirements.txt 拿到我们得项目
pip3 install -r requirements.txt
快速安装和线上相同的包

3. 管理 python 虚拟环境的工具 virtualenvwrapper

引子：为什么会出现这么一个工具呢？因为安装好virtualenv之后我们可以在任何目录创建虚拟环境，创建多了之后可能会不知道到底在哪里。还有就是你正env1中写代码，但是这时候env2线上出问题了，每次都要切换source acticate 和 deactivate很麻烦，所以才有了这个管理工具。
1.安装
	pip3 install virtualenvwrapper
	find /opt/*  virtualenv  查找
2.修改环境变量，每次开机就加在这个virtualenvwrapper工具
    # 修改文件，这个文件是用户在登陆的时候，就读取这个文件
    vim ~/.bashrc
    # 写入以下两行代码 export 读取shell变量用的
    export WORKON_HOME=~/Envs   #设置virtualenv的统一管理目录
    export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages'   #添加virtualenvwrapper的参数，生成干净隔绝的环境

# 绝对要记住下面的路径是你自己的，需要改成自己的，不要粘贴过去找不到会报错
export VIRTUALENVWRAPPER_PYTHON=/opt/python347/bin/python3     #指定python解释器
source /opt/python34/bin/virtualenvwrapper.sh #执行virtualenvwrapper安装脚本



3. 刷新一下
读取文件，使得生效，此时已经可以使用 virtalenvwrapper
source ~/.bashrc
4. 创建 env 虚拟环境
mkvirtualenv  # 自动下载虚拟环境，并创建
mkvirtualenv   djangoenv1
5. 切换虚拟环境
workon  可以直接列出所有的虚拟环境
workon djangoenv1
6. 手动推出虚拟环境
deactivate
7. 删除虚拟环境，首先要退出虚拟环境
rmvirtualenv djangoenv1
8. 列出所有的虚拟环境
lsvirtualenv
列举所有的环境。
cdvirtualenv
导航到当前激活的虚拟环境的目录中，比如说这样您就能够浏览它的 site-packages 。
cdsitepackages
和上面的类似，但是是直接进入到 site-packages 目录中。
lssitepackages
显示 site-packages 目录中的内容。


9. 在每个虚拟环境中
which python3  如果发现使用的不是当前虚拟环境下的 python3 就说明出错了
需要修改 vim /etc/profile 中的 PATH, 将自己 /opt/python36/bin 这一句移到，最前面。之后删除错误的虚拟环境，重新创建，之后进行测试，看第十步。
10. 注意这里的 path，要将物理解释器的 python，方在 path 最前面
PATH = /opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:

1577257214568

vim 编辑器：

vimer https://www.cnblogs.com/pyyu/articles/9460649.html linux vim 使用

移动光标：

w(e)　　移动光标到下一个单词
b　　　　移动到光标上一个单词
数字0　　移动到本行开头
$　　　　移动光标到本行结尾
H　　　　移动光标到屏幕首行
M　　　　移动到光标到屏幕的中间一行
L　　　　移动光标到屏幕的尾行
gg　　　 移动光标到文档的首行
G　　　　移动光标到文档尾行
ctrl + f　　下一页
ctrl + b　　上一页

`.　　移动光标到上一次的修改行

查找：

/chaoge     在整篇文档中搜索chaoge字符串,向下查找
?chaoge     在整篇文档中搜索chaoge字符串,向上查找

    

  • 

       查找整个文档，匹配光标所在的所有单词,按下n查找下一处,N上一处

    

    • 



#        查找整个文档，匹配光标所在的所有单词, 按下 n 查找下一处,N 上一处


gd        找到光标所在单词匹配的单词，并停留在非注释的第一个匹配上


%　　　　找到括号的另一半！！

删除复制黏贴：

yy    拷贝光标所在行
dd    删除光标所在行
D     删除当前光标到行尾的内容
dG    删除当前行到文档尾部的内容
p     粘贴yy所复制的内容
x　　 删除光标所在的字符
u     撤销上一步的操作

3yy　　　　拷贝光标所在的3行
5dd　　　　删除光标所在5行

底线命令：

在命令模式下输入冒号（英文的:），就进入了底线命令模式，在底线命令模式下可以输入单个或多个字符的命令，常用命令有：
:q!     强制退出
:wq!    强制写入退出
:set nu 显示行号
:数字　　调到数字那行
随时按下esc可以退出底线命令模式

:! command    暂时离开 vim 指令模式，执行command的结果
例如  :!ip a    临时看一下 ip 信息，然后可以回到 vim


:set nu　　　　显示 vim 行号
:set nonu　　　　取消行号

mariadb&mysql:

https://www.cnblogs.com/pyyu/p/9467289.html

其实就是名字不懂，都是mysql
mysql（分支mariadb）
1.安装mariadb
	- yum
	- 源码编译安装
	- 下载rpm安装
	yum和源码编译安装区别？
		1.路径区别yum安装的软件是它自定义的，源码安装的软件./configure -- prefix=软件安装的绝对路径
		2.yum安装的软件，版本可能比较低，而源码编译安装，版本可控
		3.编译安装的软件，支持第三方功能扩展./configure 这里可以加上很多参数，定制功能
	- yum仓库的区别：
		1.阿里云的yum仓库
		2.假设mysql官网，也会提供rpm包，源码包，以及yum源，供给下载
2.安装mariadb的官网yum源，用于手动下载mariadb的rpm软件包，自动安装
	注意点：阿里云提供的yum仓库，和epel源仓库，它也有mariadb,但是版本比较低
	比如阿里云提高的版本是：5.5.60-1.el7_5
	我们需要高版本的就需要选用mariadb的官方的源
3.配置管的mariadb的yum源，手动创建mariadb.repo仓库文件
	touch /etc/yum.repos.d/mariadb.repo
	然后写入如下内容：
	[mariadb]
    name = MariaDB
    baseurl = http://yum.mariadb.org/10.1/centos7-amd64
    gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
    gpgcheck=1
4.centos7安装Mariadb
	yum install MariaDB-server MariaDB-client -y
5.如果下载速度太慢，请删除mariadb.repo，只是为了使用阿里云yum中的mariadb
	rm -rf /etc/yum.repos.d/mariadb.repo
    yum clean all
6.使用阿里云的yum下载 mariadb(阿里云的mariadb是小写的，他官网的是大写的)
	yum install mariadb-setver mariadb -y
7.启动
	systemctl start/stop/restart/ mariadb 	
    systemctl enable mariadb  #设置开机启动
8.确保mariadb服务器启动后，执行命令初始化 
	mysql_secure_installation  这条命令可以初始化mysql，删除匿名用户，设置root密码等等。。。
9.设置mysql的中文版码格式，修改/etc/my.cnf
	1 
        \s 可以查看mysql的详细信息，比如：字符集
        vim /etc/my.cnf
        [mysqld]  看到这个东西，加上下面两行,使其支持中文
            character-set-server=utf8
            collation-server=utf8_general_ci
    2 
    	重启mariadb服务，读取my.cnf新配置
        systemctl restart mariadb
    3    
    	输入 \s 查看编码
10.mysql常用命令
    desc 表明  查看表结果
    create database 数据库名
    create table 表明
    show create table  表名称  查看如何创建表
   	show create database 数据库名  查看如何创建数据库的
    # 修改 mysql 的密码
    set password = PASSWORD("redhat");
    # 创建 mysql 的普通用户， 默认非常低
    create user xiaoming@'%' identified by "xiaoming"
    # 查询 mysql 数据库中的用户信息
    use mysql;
    select host,user,passwod from user;
11.给用户添加权限
	grant all privileges on *.* to 账户@主句;  对所有的库和所有的表授权所有权限
    grant all privileges on *.* to xiaoming@'%'; 给小明授权所有权限
    #刷新权限
	flush privileges;
12.授予远程登录的权限    （root不能远程登录的问题？？）
	 grant all privileges on *.* to xiaoming@'%';

<span class="hljs-comment"># 给予root用户权限授予远程登录的命令</span>
grant <span class="hljs-built_in">all</span> privileges on *.* to root@<span class="hljs-string">'%'</span> identified by <span class="hljs-string">'xiaoming'</span>;

此时可以再windows登录linux的数据库
mysql -u xiaoming -p -h <span class="hljs-number">192.20</span><span class="hljs-number">.178</span><span class="hljs-number">.32</span>



13.学习 mysql 的数据备份与恢复
# 登出 mysql，备份导出
mysqldump -u root -p --all-databases > /tmp/db.dump 导出所有文件 db，到另一个目录文件下
mysqldump -uroot -proot --databases db1 db2 > /tmp/db.dump   到处指定的库
# 登录状态，导入数据恢复
mysql -u xiaoming -p
source /tmp/db.dump   恢复数据
# 登录状态，第二种恢复数据的方式
mysql -uroot -p < /tmp/db.dump
补充：
配置文件格式
*.conf
*.cnf
*.ini
*.ymi

mysql 主从复制：

mysql的主从复制架构
mysql的主从复制架构，需要准备两台机器，并且可以通信，安装好连个mysql，保持版本一致
mysql -V 查看版本号
1.
# 停止 mysql
systemctl stop mariadb
# 修改配置文件
vim /etc/my.cnf
#修改内容
#解释：server-id 服务的唯一标识（主从之间都必须不同）；log-bin 启动二进制日志名称为 mysql-bin 
　　[mysqld]
　　server-id=1     # 标注 主库的身份 id
　　log-bin=mysql-bin    # 那个 binlog 的文件名
2.
#重启 mariadb
systemctl start mariadb
3.
mysql -V 查看版本号
# 查看主库的状态
mysql -uroot -p
show master status;  # 这个命令查看主库的二进制文件的日志信息，从库配置是会用到

scp  /etc/yum.repos.d/* root@172.20.163.39:/etc/yum.repos.d/


4.主库设置从库的配置参数
# 这些操作是在主库中进行的
1. 新建用于主从同步的用户小明, 允许登录的从库是'172.202.22.21'
create user 'xiaoming'@'172.202.22.21' identified by 'xiaoming';
2. 给从库账号授权, 说明给 chaoge 从库复制的权限，在192.168.178.130机器上复制
grant replication slave on . to 'xiaoming'@'172.202.22.21';
3.实现对主数据库锁表只读，防止数据写入，数据复制失败
flush table with read lock;  加锁
unlock tables;  解锁
4.将数据导出
mysqldump -uroot -p --all-datebases > /opt/all.dump
scpr /opt/all.dump root@172.20.22.222:/opt/   将备份数据传到从库服务器
5.在从库中进行数据导入
source /opt/all.dump;
show databses;  查看数据十分复制成功
6.
show master status; 查看数据库（主库）状态
5.从库的配置
1.设置 server-id值并关闭 binlog 功能参数
数据库的 server-id在主从复制体系内是唯一的，Slave 的 server-id要与主库和其他从库不同，并且注释掉 Slave 的 binlog 参数。
2.因此修改 Slave 的 /etc/my.cnf，写入
[mysqld]
server-id=3   # 这里的 id 必须是和主库的 id 不同，注释掉 log-bin 那一行，从库不需要
3.重启数据库
systemctl restart mariadb
4.检查 Slava 从数据库的各项参数
show variables like 'log_bin';   # 显示二进制 log 文件的状态
主库是：ON， 从库 OFF
show variables like 'server_id';
# 这个时候会出现一个问题，登录的从库的时候，会发现，原本没有设置密码但是现在有了，原因是导入了主库的所有数据之后，把主库的密码也导过来的，直接使用主库的密码登录
5.开启主从同步
配置复制的参数，Slave 从库连接 Master 主库的配置
mysql > change master to master_host='主库的 ip',
master_user='主库的用户名',
master_password='主库的密码',
master_log_file='主库的呢个 /etc/my.cnf 中的 log-bin 的值',
master_log_pos='主库 show master status; 结果中的呢个节点数字';
6.启动从库的同步开关，测试主从复制的情况
start slave;
7.查看复制状态
show slave status\G;	
主要是显示中的：
Slave_IO_Running:Yes;  yes 就是对的 , 如果是 no, 就执行第六步
Slave_SQL_Running:Yes;
# 当配置完这些后就可以在将主库的锁解掉，之后我们在主库中进行的创建、更改、删除（数据、表、库）等操作，都会在从库中赋值一份出来。
8.tip：  这一步也是很关键的，我们需要将从库设置为只读操作（root 用户之外的用户只读，root 是个变态，默认拥有所以权限，限制不了）
注意此处还未配置从库的只读模式，只需在 slave 服务器上配置 /etc/my.cnf，加上以下配置，并且在 slave 上创建普通用户，使用普通用户主从同步即可达到只读的效果, 如果用 root 用户，无法达到 readonly，这是一个坑
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
log-error=/var/log/mysqld.log
server-id=3
read-only=true
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8

redis:

https://www.cnblogs.com/pyyu/p/9843950.html

1.安装 https://www.cnblogs.com/pyyu/p/9467279.html
	yum安装：建议学习完成之后使用，
        yum install redis -y, 不要使用systemtcl
        netstat -tunlp | grep redis
    编码安装:建议学习使用
        1.下载源码包
        	wget http://download.redis.io/releases/redis-4.0.10.tar.gz
        2.解压
        	tar -zxf redis-4.0.10.tar.gz
        3.进入redis源码，直接可以编译安装
            cd redis-4.0.10
        	make && mkinstall   # 编译且安装
        4.可以指定配置文件启动redis
        	grep -v  "^#"  redis.conf | grep -v "^$"  过滤空行和注释行
            # 下面我写的每一行是一句
            注意：每次修改文件前需要杀死redis进程，之后再修改配置文件
            ps -ef | grep redis
            kill redid_pid   关闭redis
            vim redis-4.0.10/redis.conf

        <span class="hljs-number">0.</span>设置后台启动
        修改daemonize no   将no 改为yes 就可以使redis后台运行
        redsi-server redis.conf   通过配置文件启动redis
        这个时候使用windows的python脚本连接这个redis发现连不上
        <span class="hljs-comment">#  想要其他人访问你的redis </span>
        ps -ef | grep redis
        kill redid_pid   关闭redis
        之后修改vim redis.conf， 内容如下：
        
        <span class="hljs-number">1.</span> 修改redis.conf中bind参数，让redis可以远程访问
        	bind <span class="hljs-number">127.0</span><span class="hljs-number">.0</span><span class="hljs-number">.1</span>  默认是这个，只能本机方位，改为<span class="hljs-number">0.0</span><span class="hljs-number">.0</span><span class="hljs-number">.0</span> 让所有人访问
        <span class="hljs-number">2.</span>修改redis.conf中port端口，防止黑客攻击
        	port <span class="hljs-number">6379</span> 给为 <span class="hljs-number">6377</span> 随意改一个端口，不想让别人知道
        <span class="hljs-number">3.</span>修改redis.conf中 requirepass,设置redis密码，防止黑客攻击
        	设置redis的密码进行登录验证
        	redis.conf 中 requirepass 默认是被注释了的 随便设置一个值requirepass <span class="hljs-number">1</span>  这个<span class="hljs-number">1</span>就是我的密码
        	redsi-server redis.conf   通过这个配置文件启动，配置文件中设置了很多我们需要的参数
        <span class="hljs-number">4.</span>通过新的端口和密码登录redis
        	redis-cli -p <span class="hljs-number">6377</span> 
            登录后 
            auth 密码
            redis还支持交互式的参数，登录数据库
            redis-cli -p <span class="hljs-number">6377</span>  -a <span class="hljs-number">1</span>   这种方式不安全，其他人可以使用history命令，获取你的密码



2.

redis 持久化 & 发布订阅：

1.redis发布订阅
	- 三个角色
        订阅者
        发送者
        接受者
        ip a  也可以显示ip地址
    - 订阅命令
    	redis中的命令，连个redis-cli窗口
    	PUBLISH channel 频道内容   # 发布消息
    	SUBSCRIBE channel     # 订阅频道
        # 支持正则匹配的发布模式
        PUBLISH python12 频道内容   # 发布消息
        SUBSCRIBE python*     # 订阅频道

redis 持久化：

https://www.cnblogs.com/pyyu/p/10009493.html

1.redis持久化
	touch myredis.conf    可以自定义redis的配置文件
	vim myredis.conf
	# 写入下面内容
	daemonize yes
    port 6379
    logfile /data/6379/redis.log
    dir /data/6379              #定义持久化文件存储位置
    bind 10.0.0.10  127.0.0.1    #redis 绑定地址
    requirepass xiaoming            #redis 登录密码
    # 换件持久化存储文件夹
    mkdir -r data/6379    # 没这个是启动不了 redis, 或者报错
    redis-cli myredis.conf   # 使用自己的配置文件
    修改完成配置文件之后一定要重启redis服务，kill -9 redis_pid ,systemctl restart redis
2.RDB持久化
	# RDB(持久化)
    内存数据保存到磁盘
    在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）
    优点：速度快，适合做备份，主从复制就是基于RDB持久化功能实现
    rdb通过再redis中使用save命令触发 rdb
    # rdb 配置参数:
    dir /data/6379/
    dbfilename  dbmp.rdb
    # 每过 900 秒 有 1 个操作就进行持久化
    save 900秒  1个修改类的操作
    save 300秒  10个操作
    save 60秒  10000个操作
    ####################################################
	# 在 myredis.conf 中加一行
    filename myredis.rdb
    重启redis，kill -9 redis_pid,  systemctl restart redis
    这个时候data/6379还没有.rdb文件。
   	set name alex
    save     使用save 触发持久化操作
    # 之后 head data/6379/myredis.rdb 就有内容了，但是你看不懂乱码
    # 主要就是通过配置文件，以及 save 命令触发才能生效
3.AOP在持久化
	- 开启aof功能

	<span class="hljs-comment"># AOF持久化配置，两条参数 vim myredis.conf</span>
    appendonly yes
    appendfsync  always    总是修改类的操作
                 everysec   每秒做一次持久化
                 no     依赖于系统自带的缓存大小机制



4.redis 持久化方式有哪些？有什么区别？
rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于 rdb 持久化功能
aof：以追加的方式记录 redis 操作日志的文件。可以最大程度的保证 redis 数据安全，类似于 mysql 的 binlog

redis 不重启 rdb 数据切换到 aof:

1.准备rdb的redis服务端
	redis-server myreids.conf(这是在rdb持久化模式下)
	备份rdb持久化的文件
2.切换rdb到aof
	redis-cli   登录redis，通过命令，激活aof持久化
	127.0.0.1:6379> CONFIG set appendonly yes   #开启 AOF 功能（临时生效）
    OK
    127.0.0.1:6379> CONFIG SET save ""  #关闭 RDB 功能
    OK

3. 测试 aof 数据持久化
将 aof 操作，写入配置文件中，永久生效，下次 kiil 掉进程，重启生效
4. 写入数据，测试文件
使用tail -f appendonly.aof 实时动态监控文件变化

RDB 和 AOF 参数：

其中配置文件中尽量不要出现中文，有时候出现错误无法排查，莫名其妙。

# 公用参数
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379              #定义持久化文件存储位置
bind 10.0.0.10  127.0.0.1    #redis 绑定地址
requirepass redhat            #redis 登录密码
save 900 1                    #rdb 机制 每 900 秒 有 1 个修改记录
save 300 10                    #每 300 秒        10 个修改记录
save 60  10000                #每 60 秒内        10000 修改记录
# 公用参数

# RDB 参数
dbfilename  dbmp.rdb        #rdb 持久化文件
# RDB 参数


# AOF 参数
appendonly yes
appendfsync  always    总是修改类的操作
everysec   每秒做一次持久化
no     依赖于系统自带的缓存大小机制
# AOF 参数

redis 主从复制：

https://www.cnblogs.com/pyyu/p/9515937.html

# 一主两从, 其实就是让从库读取主库生成的.rdb 文件，以达到数据同步功能
1.创建三个配置文件
	touch redis-1.conf
	touch redis-2.conf
	touch redis-3.conf
	# 写入配置文件
	vim redis-1.conf
	daemonize yes
    port 6379
    logfile /data/6379/redis.log
    dir /data/6379              #定义持久化文件存储位置
    bind 10.0.0.10  127.0.0.1    #redis 绑定地址
    filename  myreids.rdb       #rdb 持久化文件
    # 通过命令快速替换写入配置文件
    sed 's/6379/6380/' redis-1.conf > redis-2.conf   # 将 redis-1.conf 里面的 6379 改成 6380 写入 redis-2.conf (其中替换只是临时的，不会改变 redis-1.conf 文件内容，但是 > 写入是持久的会在 redis-2.conf 写入改变后的真实内容)
2.创建文件夹
	mkdir -p /data/{6380,6381}   # 快速创建文件夹  -p  如果文件存在就使用原来的
    flushdb  # redis 清库命令
    # 记住下面的命令都是危险操作，尤其是第二个，很危险，可能会杀死其他人的同名进程，是你丢了工作。
    kill redis_pid or pkill  redis-server   # 支持使用名字杀死进程
3. 配置主从配置
	vim redis-2.conf
    加上一行slaveof 127.0.0.1 6379   # 指定隶属的主机端口
	vim redis-3.conf
    加上一行slaveof 127.0.0.1 6379

redic-cli -p <span class="hljs-number">6379</span> info    <span class="hljs-comment"># 查看详细信息，其中每一#注释就是一个字典的key</span>
redic-cli -p <span class="hljs-number">6379</span> info  Replication   <span class="hljs-comment"># 查看Replication这个key的值</span>



4.redis 主从复制，手动进行主从复制故障切换
# 加入主库 6379 端口故障挂了，我们从两个从库中选取一个作为主库进行写操作
kill redis_6379_pid
1.进入 redis-cli -p 6380
info replication  # 查看状态信息
2.解除自身隶属关系
slaveof no one    # 解除关系
3.将6381设置为6380的从库
redis-cli -p 6381
slaveof no one    # 解除关系
slaveof 127.0.0.1 6380
4.这个时候再检查6380，和6381的关系
info replication  # 查看状态信息

redis 哨兵：

https://www.cnblogs.com/pyyu/p/9718679.html

# Redis-Sentinel
不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识
如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也人为主节点不可达，就会选举一个sentinel节点来完成自动故障转义
在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

1.什么是哨兵呢？保护 redis 主从集群，正常运转，当主库挂了之后，自动从从库中挑选新的主库，进行同步
2.多个哨兵之间是通过我们上边学到的发布订阅实现的，多个哨兵同时监听同一个频道，来实现通信
3.redis 哨兵的安装配置
我们测试三个哨兵
1.准备三个 redis 数据库实例（三个配置文件，通过端口区分）
redis-server redis-1.conf
redis-server redis-2.conf
redis-server redis-3.conf
2.准备三个哨兵配置文件
touch redis-sentinel-26379.conf
vim redis-sentinel-26379.conf


    <span class="hljs-comment"># 写入下面内容</span>
    port <span class="hljs-number">26379</span>  
    <span class="hljs-built_in">dir</span> /var/redis/data/
    logfile <span class="hljs-string">"26379.log"</span>
    sentinel monitor myredis(自己定义,就是在哨兵文件中给主库起一个别名，主库需要设置) <span class="hljs-number">127.0</span><span class="hljs-number">.0</span><span class="hljs-number">.1</span> <span class="hljs-number">6379</span> <span class="hljs-number">2</span>（这个参数的意思是几个哨兵同意可以换主人）
    sentinel down-after-milliseconds myredis <span class="hljs-number">30000</span>
    sentinel parallel-syncs myredis <span class="hljs-number">1</span>
    sentinel failover-timeout myredis <span class="hljs-number">180000</span>
    
    <span class="hljs-comment"># 内容</span>
    prot <span class="hljs-number">26379</span>
    <span class="hljs-built_in">dir</span> /var/redis/data/
    logfile <span class="hljs-string">"26379.log"</span>
    sentinel moitor myredis <span class="hljs-number">127.0</span><span class="hljs-number">.0</span><span class="hljs-number">.1</span> <span class="hljs-number">6379</span> <span class="hljs-number">2</span>
    sentinel dowm-after-milliseconds myreids <span class="hljs-number">300000</span>
    sentinel parallel-syncs myredis <span class="hljs-number">1</span>
    sentinel failover-timeout myreids <span class="hljs-number">1800000</span>

    <span class="hljs-comment"># 快速生成其他两个配置文件（仅仅只是配置文件端口的不同）</span>
    sed <span class="hljs-string">'s/26379/26380/g'</span> redis-sentinel-<span class="hljs-number">26379.</span>conf &gt; redis-sentinel-<span class="hljs-number">26380.</span>conf

    sed <span class="hljs-string">'s/26379/26381/g'</span> redis-sentinel-<span class="hljs-number">26379.</span>conf &gt; redis-sentinel-<span class="hljs-number">26381.</span>conf
<span class="hljs-number">3.</span>添加后台运行参数，使得哨兵服务进程在后台运行
	echo <span class="hljs-string">"daemonize yes"</span> &gt;&gt; redis-sentinel-<span class="hljs-number">26379.</span>conf
    echo <span class="hljs-string">"daemonize yes"</span> &gt;&gt; redis-sentinel-<span class="hljs-number">26380.</span>conf
    echo <span class="hljs-string">"daemonize yes"</span> &gt;&gt; redis-sentinel-<span class="hljs-number">26381.</span>conf
 <span class="hljs-number">4.</span>启动redis-sentinel
	redis-sentinel redis-sentinel-<span class="hljs-number">26379.</span>conf   <span class="hljs-comment"># 启动</span>
    sed -i <span class="hljs-string">'s/mymaster/myredis/g'</span> redis-sentinel-<span class="hljs-number">26379.</span>conf   <span class="hljs-comment"># -i参数直接更改文件</span>
    ps -ef | grep sentinel  <span class="hljs-comment"># 查看哨兵进程起来没有</span>
 <span class="hljs-number">5.</span>查看哨兵的通信信息
	redis-sentinel -p <span class="hljs-number">26379</span> info sentinel
    <span class="hljs-comment"># Sentinel</span>
    sentinel_masters:<span class="hljs-number">1</span>
    sentinel_tilt:<span class="hljs-number">0</span>
    sentinel_running_scripts:<span class="hljs-number">0</span>
    sentinel_scripts_queue_length:<span class="hljs-number">0</span>
    sentinel_simulate_failure_flags:<span class="hljs-number">0</span>
    master0:name=mymaster,status=ok,address=<span class="hljs-number">192.168</span><span class="hljs-number">.119</span><span class="hljs-number">.10</span>:<span class="hljs-number">6379</span>,slaves=<span class="hljs-number">2</span>,sentinels=<span class="hljs-number">3</span>    
    <span class="hljs-comment">#看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是192.168.119.10:6379，有两个从节点，3个哨兵</span>
 <span class="hljs-comment"># 进行测试哨兵是否真的可以起作用   </span>
 <span class="hljs-number">6.</span>杀死一个redis主库，<span class="hljs-number">6379</span>节点，等待30s以内，检查<span class="hljs-number">6380</span>和<span class="hljs-number">6381</span>状态
    redis-cli -p <span class="hljs-number">6380</span> info replication
    redis-cli -p <span class="hljs-number">6381</span> info replication
    redis-cli -p <span class="hljs-number">63791</span> info replication
    kill <span class="hljs-number">6379</span>主节点
    如果切换主从身份之后，（原理就是更爱redis的配置文件，切换主从身份）
 <span class="hljs-number">7.</span>恢复<span class="hljs-number">6379</span>节点的数据库，查看是否将<span class="hljs-number">6379</span>添加为新的从节点数据库
	redis-server redis-<span class="hljs-number">1.</span>conf
    redis-cli -p <span class="hljs-number">6379</span>
    redis-cli -p <span class="hljs-number">6379</span> info replication  <span class="hljs-comment"># 6379端口主从信息</span>
    <span class="hljs-comment"># Replication</span>
    role:master
    connected_slaves:<span class="hljs-number">1</span>
    slave0:ip=<span class="hljs-number">127.0</span><span class="hljs-number">.0</span><span class="hljs-number">.1</span>,port=<span class="hljs-number">6381</span>,state=online,offset=<span class="hljs-number">41814</span>,lag=<span class="hljs-number">1</span>

redis_cluster 安装配置：

1.准备6个redis数据库实例，准备6个配置文件redis-{7000....7005}.conf
	# 创建文件夹
	mkdir s15rediscluster
	cd s15rediscluster
	touch redis-7000.conf
	# 编辑配置文件
	vim redis-7000.conf
	# 加上下面的东西
	port 7000
    daemonize yes
    dir "/opt/redis/data"
    logfile "7000.log"
    dbfilename "dump-7000.rdb"
    cluster-enabled yes   #开启集群模式
    cluster-config-file nodes-7000.conf　　#集群内部的配置文件

# 穿件目录
mkdir -p /opt/redis/data
# 生成5个配置文件
sed 's/7000/7001/g' redis-7000.conf &gt; redis-7001.conf
sed 's/7000/7002/g' redis-7000.conf &gt; redis-7002.conf
sed 's/7000/7003/g' redis-7000.conf &gt; redis-7003.conf
sed 's/7000/7004/g' redis-7000.conf &gt; redis-7004.conf
sed 's/7000/7005/g' redis-7000.conf &gt; redis-7005.conf

# 启动6个redis实例
redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf


	
	# ps -ef | grep redis
2.配置ruby环境
	1 下载ruby源码包
		wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
	3 解压
		tar -xvf ruby-2.3.1.tar.gz
	3 释放makefile文件		
        ./configure --prefix=/opt/ruby/  # 指定ruby安装到哪里
        等出现makefile文件出现
    4 编译
        make && make install   # 编译安装，这个时候ruby已经安装完成
    5 
    	cd /otp/ruby/
  	6 配置ruby的环境变量
  		echo $PATH
  		vim /etc/profile
  		写入最低行
  		PAHT=$PATH:/opt/ruby/bin/
  		wq!退出
  		source /etc/profile   重新加载一下

7 下载安装ruby操作redis的软件，
	cd /opt/
	wget http://rubygems.org/downloads/redis-3.3.0.gem
	# 直接安装
    gem install -l redis-3.3.0.gem   # 安装，安装完成之后会生成一个redis-trib.rb命令
     
    find /opt -name redis-trib.rb  # 寻找ruby的redis管理包
    /opt/redis-3.3.0.gem/src/redis-trib.rb   # 绝对路径
    # 配置redis-trib.rb到环境变量
    #cp /opt/redis/src/redis-trib.rb /usr/local/bin/
8 使用redis-trib.rb命令，一键创建redis-cluster集群，其实就是分配主从关系，以及，槽位，slot槽位分配
	#每个主节点，有一个从节点，代表--replicas 1
    redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

    #集群自动分配主从关系  7000、7001、7002为 7003、7004、7005 主动关系
    
9 检查redis节点主从状态
	redis-cli -p 6700 info replication
	
10 查看集群状态
	redis-cli -p 7000 cluster info
	redis-cli -p 7000 cluster nodes  #等同于查看nodes-7000.conf文件节点信息
    集群主节点状态
    redis-cli -p 7000 cluster nodes | grep master
    集群从节点状态
    redis-cli -p 7000 cluster nodes | grep slave
    # 命令执行结果展示
    [root@yugo /opt/redis/src 18:42:14]#redis-cli -p 7000 cluster info
    cluster_state:ok   # 状态ok
    cluster_slots_assigned:16384  # 已经分配的槽位
    cluster_slots_ok:16384  # ok的槽位
    cluster_slots_pfail:0  
    cluster_slots_fail:0
    cluster_known_nodes:6  # 一共有几个节点的redis
    cluster_size:3
    cluster_current_epoch:6
    cluster_my_epoch:1
    cluster_stats_messages_ping_sent:10468
    cluster_stats_messages_pong_sent:10558
    cluster_stats_messages_sent:21026
    cluster_stats_messages_ping_received:10553
    cluster_stats_messages_pong_received:10468
    cluster_stats_messages_meet_received:5
    cluster_stats_messages_received:21026
11 向redis写入数据，查询数据流向
	# 这里会自动将key按照一个算法模式重定向到其他槽位，同时会切换redis实例，获取的时候，同样会自动切换
	redis-cli -p 7000 -c   # -c查看集群
	set name alex
	set addr shasj
——————————————————————————————————————————————————————————————————————————	
例子：
127.0.0.1:7000&gt; set name chao     # 这里在7000端口设置了一个值
-&gt; Redirected to slot [5798] located at 127.0.0.1:7001   # 他讲这个key重定向到了7001端口     
OK
127.0.0.1:7001&gt; exit  # 这里发现没有切换到了7001，
[root@yugo /opt/redis/src 18:46:07]#redis-cli -c -p 7000
127.0.0.1:7000&gt; ping
PONG
127.0.0.1:7000&gt; keys *    # 这个时候查看7000端口的key是空的
(empty list or set)
127.0.0.1:7000&gt; get name   # 但是你在获取的时候，他又会重定向到7001获取对应的值
-&gt; Redirected to slot [5798] located at 127.0.0.1:7001
"chao"

软件安装总结：

1.在linux服务器上安装软件
	分好几种：
	 	-yum安装
	 		- 配置yum源，配置163，清华，阿里云的yum源
	 		- 清空yum缓存
	 		- 生成新的yum缓存
	   	- 源码安装：
	   		- 下载软件的源码压缩包
	   		- 解压切换目录
	   		- 释放makefile，编译，安装
	    - rpm 软件包安装
2.mariadb
 	1.yum安装
 		yum install mariadb-server mariadb -y
 	2.安装好之后，启动服务端，只有通过yum安装的软件才能使用systemctl管理
 		systemctl start mariadb
 		如果这一步不启动的话，或报错：找不到mysql.sock文件
 	3.数据库初始化
 	4.mysql -uroot -p 
 3.redid
 	1.源码包安装redis
 	2.指定了/opt/redis/工作目录
 	3.qidongredis服务端
 		redis-server redis.conf  指定配置文件，
 	4.软件的配置文件作用
 		给这个软件，指定开发、关闭一些功能
 		改redis端口
 		改redis面
 		redis的安全模式
 		bing参数，指定redis启动的ip地址

nginx 入门：

这个东西必须学，redis 你可以不懂 nginx 必须懂。

https://www.cnblogs.com/pyyu/p/9468680.html

web服务器软件
windows
	IIS服务器
linxu
	nginx
	apache  收费
	lighthttp
公司的技术栈
收费版技术栈
apache web服务器+java+tomcat应用服务器+oracle+memcached+redhat企业版linxu+suv(代码管理工具)
开源的技术栈（路飞学城）
nginx（负载均衡）+ python（virtualenv）+ uwsgi(python的应用服务器，启动了10个进程处理django drf请求) + mysql （阿里云的rds主从复制）+ redis的主从复制 + git + vue 前端代码服务器 + linux(阿里云的centos7)

curl -i 网站域名   # 可以查看网站的响应头信息   查看网站是用什么服务器
1.下载 nginux 依赖包，不安装后面会报错，各种问题
yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel openssl openssl-devel -y
2.安装配置 nginux 软件
cd /opt/
# 下载源码包
wget -c https://nginx.org/download/nginx-1.12.0.tar.gz
3.解压源码文件，编译安装
# 解压
tar -zxvf nginx-1.12.0.tar.gz
# 释放 makefile 文件，指定安装目录, 同时开启 nginx 的状态监控
./configure --prefix=/opt/nginx1-12/ --with-http_ssl_module --with-http_stub_status_module
# 安装
make && make install
4.进入 nginx 的工作目录
cd /opt/nginx-12
5.查看 nginx 的工作目录
[xiaoming@localhost ~]$ ls
conf   配置文件目录
html   网页根目录，你的 index.html 就放在这里，然后 ton 过域名访问， pythonav.cn/index.html
logs   日志文件
sbin   存放 nginx 可执行命令
# 启动 nginx，进入 sbin 目录，肇东 niginx 启动命令
cd nginx-12/sbin
./nginx   # 启动
./nginx -s stop # 关闭
./nginx -s reload  # 重新加载
# 查看 nginx 端口进程信息
netstat -tunlp | grep nginx
curl -i 127.0.0.1
# 如果访问不了，就检查 selinux,iptable 防火墙
6.关闭防火墙
iptables -L  # 查看防火墙状态
getenforce   # 查询防火墙状态
setenforce 0  # 关闭防火墙
cd sbin/
./nginx    # 启动 nginx
7.盗取一个测试网站试试
cd ../html
vim index.html    # 将这个里面的文件全部删除，去网页上拷贝一个网页，粘贴在里面
wq! # 退出
# 这个时候你在次通过浏览器访问你本机的 ip 他会显示你盗取的页面。我感觉这个东西挺危险的，如果在这里你通过我盗取的网址登陆操作，我应该是可以拿到的用户名和密码的。
# 如果网页不识别中网加上
<meta charset=utf-8>

nginx 配置文件学习：

# 切换目录
cd /opt/nginx-12/conf
vim nginx.conf
gerp -v "^#$" | grep -v "^$"  # 过滤空行和注释行

#nginx 进程数，建议设置为等于 CPU 总核心数。
worker_processes 8;  nginx 工作进程数，根据 cpu 的核数定义
events
{
worker_connections 65535;  # 连接数
}


http   # http 区块，定义 nginx 的核心 web 功能
{
#文件扩展名与文件类型映射表
include( 关键字） mime.types（自定义格式）;


<span class="hljs-comment">#默认文件类型</span>
default_type application/octet-stream;
<span class="hljs-comment"># 日志信息</span>
log_format  main <span class="hljs-string">'$remote_addr - $remote_user[$time_local] "$request"'</span>
        	     <span class="hljs-string">'$status $body_bytes_set "$http_referer"'</span>
        		 <span class="hljs-string">'"$http_user_agent" "$http_x_forwarded_for"'</span>
<span class="hljs-comment"># 开启访问日志</span>
access_log  logs/access.log main;
sendfile   on;
<span class="hljs-comment"># tcp_nopus   on;</span>
<span class="hljs-comment"># keepalive_timeout   0;</span>
<span class="hljs-comment"># 连接保持多久,保持长连接</span>
keepalive_timeout   <span class="hljs-number">65</span>;     
<span class="hljs-comment"># 支持图片gif等等压缩，减少带宽</span>
gzip on ;
<span class="hljs-comment">#虚拟主机的配置</span>
server{
    <span class="hljs-comment">#监听端口</span>
    listen <span class="hljs-number">80</span>;
    <span class="hljs-comment">#域名可以有多个，用空格隔开</span>
    server_name www.w3cschool.cn w3cschool.cn;
    <span class="hljs-comment"># 定义编码格式</span>
    charset utf-<span class="hljs-number">8</span>;
    <span class="hljs-comment"># 定义网页的的访问url</span>
    <span class="hljs-comment"># 比如下面的用户访问格式就是127.0.0.1/av，</span>
    location /av{  <span class="hljs-comment"># 这里的av不写默认访问127.0.0.1，具体ip看你自己的，我这里随便写的一个ip</span>
        <span class="hljs-comment"># root参数定义网页根目录，你的前段页面从哪里读</span>
        root html;
        <span class="hljs-comment"># 定义网页的首页页面，网页404就有可能是这里的路径没有配置正确</span>
        index index.html index.htm;
    }
    <span class="hljs-comment"># 定义错误页面，客户端的错误，就会返回40x系列状态码</span>
    errot_page <span class="hljs-number">404</span> <span class="hljs-number">403</span>      /<span class="hljs-number">404.</span>html
    <span class="hljs-comment"># 50X系列错误码代表后端代码出错</span>
    errot_page <span class="hljs-number">501</span> <span class="hljs-number">500</span>      /<span class="hljs-number">404.</span>html
    }        



}
# 查看 cpu 信息
cat /et/cpuinfo  or top  只输入1

nginx 虚拟主机：

就是在一个配置文件在定义多个 server 配置项，分配各自的内存空间，其实就是创建一个文件夹，在下面用同一个配置文件，起 nginx 服务。

# 创建给的内存空间
cd /opt/myserver
mkdir {oumei,rihan}   # 这个就是你网站或者可以说虚拟主机的文件夹
# 同时我们需要让自己的服务器解析两个域名 www.tttoumei.com，www.ttt 日韩.com
vim /etc/hosts   # 编辑这个文件加上
127.0.0.1   www.tttoumei.com
127.0.0.1   www.tttrihan.com
使得我们这台服务器的ip对应连个域名就可以了
----------------------------------------------------------------------------
# 比如我们现在在一个 nginx 上起连个网址，就是配置两个 server，改一下其中的 server_name, 和 location 下的 root 目录就行了
vim /opt/nginx12/conf/nginx/conf

server{
#监听端口
listen 80;
#域名可以有多个，用空格隔开
server_name www.tttoumei.com;
# 定义编码格式
charset utf-8;
# 定义网页的的访问 url
# 比如下面的用户访问格式就是 127.0.0.1/av，
location /av{  # 这里的 av 不写默认访问 127.0.0.1，具体 ip 看你自己的，我这里随便写的一个 ip
# root 参数定义网页根目录，你的前段页面从哪里读
root /opt/myserver/oumei;
# 定义网页的首页页面，网页 404 就有可能是这里的路径没有配置正确
index index.html index.htm;
}
# 定义错误页面，客户端的错误，就会返回 40x 系列状态码
errot_page 404 403      /404.html
# 50X 系列错误码代表后端代码出错
errot_page 501 500      /404.html
}
server{
#监听端口
listen 80;
#域名可以有多个，用空格隔开
server_name www.tttrihan.com;
# 定义编码格式
charset utf-8;
# 定义网页的的访问 url
# 比如下面的用户访问格式就是 127.0.0.1/av，
location /av{  # 这里的 av 不写默认访问 127.0.0.1，具体 ip 看你自己的，我这里随便写的一个 ip
# root 参数定义网页根目录，你的前段页面从哪里读
root /opt/myserver/rihan;
# 定义网页的首页页面，网页 404 就有可能是这里的路径没有配置正确
index index.html index.htm;
}
# 定义错误页面，客户端的错误，就会返回 40x 系列状态码
errot_page 404 403      /404.html
# 50X 系列错误码代表后端代码出错
errot_page 501 500      /404.html
}


./sbin/nginx -t  # 测试我们写的配置文件是否是对的，如果有语法错误，会报错
pkill nginx    # 杀死 nginx 进程
./sbin/nginx   #启动 nginx


我们都配置好了，这个时候使用, 我们是用 windows 访问，发现访问不到，是问什么哪？是因为这个域名是我们自己随便遍的，公网上没有这个域名，你根本访问不到，但是我们又想测试咋办，只有强行更改我们得 hosts 文件，当时用浏览器访问的时候会先去我们得 hosts 文件中解析对应的 ip，如果找不到才回去公网找，我们直接强制性的对 ip 和域名进行了解析。

nginx 的访问日志:

1.开启nignx配置中的日志参数
log_format  main '$remote_addr - $remote_user[$time_local]"$request"'
            	     '$status $body_bytes_set"$http_referer"'
            		 '"$http_user_agent" "$http_x_forwarded_for"'
# 开启访问日志，就是将原来的注释放开就行了，它会自动生成日志文件
access_log  logs/access.log main;
1.检查access.log的日志信息
tail -f access.log

nginx 限制 ip:

vim /opt/nginx12/conf/nginx.conf
# 假设他访问的是这个域名
location /av{  # 这里的 av 不写默认访问 127.0.0.1，具体 ip 看你自己的，我这里随便写的一个 ip
    # 直接拒绝这个 ip 访问
    deny 193.168.11.11；  # 这里也可以拒绝一整个网段的访问 ip/ 子网页码
    # root 参数定义网页根目录，你的前段页面从哪里读
    root /opt/myserver/oumei;
    # 定义网页的首页页面，网页 404 就有可能是这里的路径没有配置正确
    index index.html index.htm;
        }

nginx 错误页面优化：

# 修改 error_page 参数
vim /opt/nginx12/conf/nginx.conf
server 下加一个参数
error_page  404   /my404.html
cd /opt/myserver/rihan/
touch my404.html   # 修改显示页面，可以直接去复制一个，比如淘宝的错误页面

nginx 反向代理：

vpn就是正向代理
中国的用户，在自己的机器上，访问香港的一个(vpn)服务器的ip，通过这个(vpn)服务器的ip地址和外部进行通信，访问google。

nginx 的反向代理功能（自带反向代理功能，天生的二道贩子）
1.实验环境准备
准备两个服务器，2个 nginx
nginx1     172.20.110.100   反向代理服务器
nginx1     172.20.110.101   作为 web 服务器
2.更改172.20.110.100的 /opt/nginx12/conf/nginx.conf 文件
server > location 中将其他参数注释掉，加上一个
proxy_pass http://172.20.110.101:
# 如下：
location /{
proxy_pass http://172.20.110.101:   # 我们需要的资源在这个 ip 地址的服务器，通过凡响的代理我们可以访问的服务器
}

1577430556833

nginx 负载均衡：

集群：
	关于它优点，就简单的说一下。第一点便宜，你可以使用多台机器构成一个集群；第二点抗压性好，点单的服务器你性能再好，断电你还牛逼不，我把集群布置在好几个城市，就算一个地方断电了，其他地方还有啊。牛逼的话，可以把它弄得像蜘蛛网一样，一个点炸了，不影响其他服务器运行。

负载均衡：
缓解压力，无数个用户访问同一个网站，但是这个网站通过多台服务器搭建环境，通过一个算法，分配给不同的服务器，缓解服务器的压力。只有一台服务器的话，百万级别的访问，一次性基本就死机了。


1.实验准备
准备三个计算机
nginx1  172.20.110.102 作为 ngin 负载均衡器  只要我访问这个负载均衡服务器，查看页面的结果，到底是来自那个 web 服务器就知道有没有效果


nginx2 172.20.110.100 web 服务器，提供一个页面
nginx3 172.20.110.101 web 服务器，提供一个页面


2.先配置两个 nginx 页面 web 页面
172.20.110.100  准备一个 index.html 写入  python 从入门到放弃
172.20.110.101  准备一个 index.html 写入  linux 从满头乌发到光明绝顶
然后启动两个 nginx，出问题找防火墙
# 查询 selinux 状态
getenforce
# 暂时停止 selinux
setenforce 0


3.准备一个负载均衡服务器172.20.110.102，修改他的配置文件
/opt/nginx12/conf/nginx.conf
# 配置负载均衡池
upstream webserver{   # 定义负载均衡池，这里默认的算法是轮轮询算法
# [默认]
# server 172.20.110.100;
# server 172.20.110.101;


<span class="hljs-comment"># [权重]</span>
<span class="hljs-comment"># server 172.20.110.100 weight=100;   # 权重算法</span>
<span class="hljs-comment"># erver 172.20.110.101 weight=1;</span>

[ip_hash]    <span class="hljs-comment"># 根据一个哈希算法进行的</span>
ip_hash;
server <span class="hljs-number">172.20</span><span class="hljs-number">.110</span><span class="hljs-number">.100</span>;
server <span class="hljs-number">172.20</span><span class="hljs-number">.110</span><span class="hljs-number">.101</span>;



}
# server > location 中配置
location /{
proxy_pass webserver;  # 分配给负载均衡池
}


4.启动负载均衡器的 nginx 服务
ps -ef | grep nginx    # 先查看这个服务器是否启动这
netstat -tunlp | grep nginx  # 看看端口
kill nginx 端口 pid or pkill nginx # (第二种方式还是尽量少用，除非你确定需要杀死所有的包含 nginx 的进程，否则会杀死其他人正在应用的进程)


5.在客户端 windows 中测试访问，负载均衡，查看请求分发的结果172.20.110.102，查看请求分发的结果
tail -f log/access.log   # 查看三个 log 文件的访问情况


下面有具体配置，步骤自行查看


编辑配置文件，主要是负载均衡器的配置文件，其他连个服务器，就像上几个里面可以返回一个 html 页面就行了
[xiaoming@172.20.110.102 ~]$ vim /opt/nginx12/conf/nginx.conf
在配置文件和 server 同级配置如下参数
upstream webserver{   # 定义负载均衡池，这里默认的算法是轮轮询算法
# [默认]
# server 172.20.110.100;
# server 172.20.110.101;


<span class="hljs-comment"># [权重]</span>
<span class="hljs-comment"># server 172.20.110.100 weight=100;   # 权重算法</span>
<span class="hljs-comment"># erver 172.20.110.101 weight=1;</span>

[ip_hash]
ip_hash;
server <span class="hljs-number">172.20</span><span class="hljs-number">.110</span><span class="hljs-number">.100</span>;
server <span class="hljs-number">172.20</span><span class="hljs-number">.110</span><span class="hljs-number">.101</span>;



}


server{
#监听端口
listen 80;
# 当我的请求来在 172.20.110.102 时，走这个虚拟主机
server_name 172.20.110.102;
# 定义编码格式
charset utf-8;
# 定义网页的的访问 url
# 比如下面的用户访问格式就是 127.0.0.1/av，
location /av{  # 这里的 av 不写默认访问 127.0.0.1，具体 ip 看你自己的，我这里随便写的一个 ip
proxy_pass webserver;  # 分配给负载均衡池
}
# 定义错误页面，客户端的错误，就会返回 40x 系列状态码
errot_page 404 403      /404.html
# 50X 系列错误码代表后端代码出错
errot_page 501 500      /404.html
}


再来练习加入环境变量
echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/xiaoming/.local/bin:/home/xiaoming/bin
vim /etc/profile
PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/python36/bin/:/opt/nigix12/sbin
wq!  退出

项目部署：https://www.cnblogs.com/pyyu/p/10160874.html

Linux项目部署之发布路飞学城

python3
uwsgi  wsgi（web 服务器的网关接口，就是实现一个 python web 应用的协议）
MTV


virtualenvwrapper
路飞的代码
vue 的代码
nginx
mysql
redis
supervisor 进程管理工具
1.部署环境准备
cd /opt/python3/bin
pip intall -i https://www/pypi.douban.com/simple virtualenvwrapper
2.修改 python3 的环境变量，写入到 /etc/proflie
3.修改 ~/.bashrc
写入变量
# 修改文件，这个文件是用户在登陆的时候，就读取这个文件
vim ~/.bashrc
# 写入以下两行代码 export 读取 shell 变量用的
export WORKON_HOME=~/Envs   #设置 virtualenv 的统一管理目录
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages'   #添加 virtualenvwrapper 的参数，生成干净隔绝的环境


<span class="hljs-comment"># 绝对要记住下面的路径是你自己的，需要改成自己的，不要粘贴过去找不到会报错</span>
export VIRTUALENVWRAPPER_PYTHON=/opt/python347/<span class="hljs-built_in">bin</span>/python3     <span class="hljs-comment">#指定python解释器</span>
source /opt/python34/<span class="hljs-built_in">bin</span>/virtualenvwrapper.sh <span class="hljs-comment">#执行virtualenvwrapper安装脚本</span>



4.新建一个虚拟环境
mkvirtualenv luffycityenv
5.下载代码，前后端
mkdir luffycity
cd luffycity
wget url 代码


6.解压代码
unzip 压缩包   # 解压 zip 文件
unzip luffycity.zip


7.从 vue 前段环境打包
1.
下载 node 二进制包，此包已经包含 node，不需要再编译
wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz
解压缩
tar -zxvf node-v8.6.0-linux-x64.tar.gz
进入 node 文件夹
[root@web02 opt]# cd node-v8.6.0-linux-x64/
[root@web02 node-v8.6.0-linux-x64]# ls
bin  CHANGELOG.md  etc  include  lib  LICENSE  README.md  share
[root@web02 node-v8.6.0-linux-x64]# ls bin
node  npm  npx
[root@web02 node-v8.6.0-linux-x64]# ./bin/node -v
v8.6.0
[root@web02 node-v8.6.0-linux-x64]# ./bin/npm -v
5.3.0
#配置环境变量
vim /etc/profile
PATH=$PATH:/opt/ndoe-v8.6.0-linux-x64/bin
source /et/profile
# 检测 node 版本
node -v
npm -v


<span class="hljs-number">2.</span>安装node模块，打包node项目
cd cd 07-luffy_project_01/
npm install
<span class="hljs-comment"># 这里有一个问题，我们得本地测试的时候是访问127.0.0.1，需要修改代码里面的ip</span>
npm run build  <span class="hljs-comment"># 生成一个dist文件夹，整个前段项目的内容和index.html都ok了</span>

<span class="hljs-number">3.</span>等待nginx访问这个dist文件





8.部署后端的所需的环境
1.激活虚拟环境
workon luffycityenv
2.通过一条命令，到处本地的所有软件包依赖
pip3 freeze > requirements.txt
3.将这个 requirements.txt 传送到服务器，在服务器的新的虚拟环境中，安装这个文件，就可以安装所有的依赖包
pip3 install requirements.txt
4.安装 uwsgi, 支持该高并发的启动 python 项目 (注意 uwsgi 不支持静态文件的解析，必须使用 nginx 配置解析)
1.安装 uwsgi
pip3 install -i https://www.douban.com/simple uwsgi
2.学习使用 uwsgi
# 通过 uwsgi 启动 python 文件
uwsgi --http:8000 --wsgi-file tets.py
--http 指定 http 协议
--wsgi-file 指定一个 python 文件
touch tets.py
vim tets.py
def application(env,start_response):
start_response("200 OK", [['Content-Type', 'text/html']])
return [b'hello xiaoming']
3.通过 uwsgi 启动 django 测试项目
django-admin startproject  testpj
vim testpj/settings
ALLOW_HOSTS=[*]
4.启动正式项目，并支持热加载
# --py-autoreload=1  不重启项目，自动更新加载后端代码
uwsgi --http:8000 --module luffycity.wsgi --py-autoreload=1
--http 指定 http 协议
--module 指定找到 django 项目的 wsgi.py 文件
5.使用 uwsgi 的配置文件，启动项目
touch uwsgi.ini
[uwsgi]
[uwsgi]
# Django-related settings
# the base directory (full path)
# 指定项目的第一层绝对路径，必须绝对路径到你的项目 (这里是项目不是 app)
chdir           = /opt/luffucity/luffy_body/lf_code
# Django's wsgi file
# 指定项目的 wsgi.py 文件
# 写入相对路径即可，这个参数是以 chdir 参数为相对路径
module          = lf_code.wsgi  # lf_code 是 app 的目录名称
# the virtualenv (full path)
# 写入虚拟幻境解释器的绝对路径
# cdvirtualenv  切换到虚拟环境
# pwd   查看路径
# /opt/Envs/luffycity
home            = /opt/Envs/luffycity
# process-related settings
# master
master          = true
# maximum number of worker processes
# 启动进程数 ( 意味着会启动 5 个后端程序, 如果其中每个进程中都有定时任务, 会启动五个; 举个例子把, 我做了一个限流程序, 相关数据保存在 Redis 中,
出现了五个后端同时向一个 redis 写数据的问题, 而且不理解这个参数, 就会找不到问题出在哪里 )
processes       = 5
# the socket (use the full path to be safe
# 指的是，uwsgi 启动一个 socket 连接，当你使用 nginx+uwsgi 的使用，使用 socket 参数
socket          = 0.0.0.0:8000
# 当你只使用 uwsgi 的时候，使用这个参数，uwsgi 启动一个 http 连接，socket 和 http 同时只能使用一个
# http            = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum          = true
daemonize       = yes   # 后台启动
6.指定配置文件启动命令  		
uwsgi --ini 	/opt/luffucity/luffy_body/lf_code/uwsgi.ini
kill -9 uwsgi_pid
7.使用 supervisor 进程管理工具对进程进行管理
# 具体用法请看 -》下面的supervisor: 进程管理工具：
supervisorctl -c /etc/supervisor.cong


5.使用 nginx
1.编译安装 nginx
2.nginx.conf 配置如下
# 第一个 server 虚拟主机是为了找到 vue 的 dist 文件，找到路飞的 index.html
server{
listen 80;
server_name 192.168.13.79;
charset utf-8;
#请求 192.168.13.79/ 时。直接进入 location，然后找到 vue 的 dis/index.html
location /{
root /opt/luffycit/07-luffy_project_01/dist;
index index.html index.htm;
}
# access-log logs/host.access.log main;
# 由于 vue 发送的数据接口	地址是 192.168.13.79：8000， 我们还等准备一个入口 server
server{
listen 8000;
server_name 192.168.13.79;
charset utf-8;
# 当接收到数据接口是，请求 url 是 192.168.13.79：8000，就进入如下 location
location /{
# 这里是 nginx 将请求转发给 uwsgi 启动的 9000 端口
uwsgi_pass 192.168.13.79:9000;
# include 就是一个包含，就是将外部一个文件的参数，导入到当前的 nginx。cong 中生效
include /opt/nginx12/conf/uwsgi_params;
}


9.关于 django 的静态文件配置
mysite/settings.py
STATIC_ROOT='/opt/nginx1-12/static'  # 收集所有的静态文件，到这个目录
STATIC_URL = '/static/'
STATICFILES_DIRS=[
os.path.join(BASE_DIR,"static"),
]
python3 manage.py collectstatic    收集你的静态文件保存到  STATIC_ROOT 下
# 配置 nginx 处理静态文件
在上一个 locations 同级再添加一个 location
location /static {
alias /opt/nginx1-12/static;   # 别名
}

supervisor: 进程管理工具：

1.将linux程序运行在后台的方法有哪些
    第一个，命令后面加上&符号
    python manage.py runserver &
    第二个，使用nohup
    第三个，使用进程管理工具
2.安装supervisor,使用python2的包管理工具easy_install安装，注意此时需要退出虚拟环境
	yum install python-setuptools  # 安装 easy_install, 如果没有
	easy_install supervisor
3.通过命令生成配置文件
	echo_supervisord_conf > /etc/supervisor.conf
4.编辑这个配置文件,写入创建django项目的配置
	vim /etc/supervisor.conf
    直接跳到最后G,添加你自己的配置
    [program:xx]是被管理的进程配置参数，xx是进程的名称
    #写入一下配置
    [program:luffycity_uwsgi]
    command=/opt/Envs/luffycity/bin/uwsgi --ini /opt/luffucity/luffy_body/lf_code/uwsgi.ini; # 程序启动命令
5.启动supervisord服务端，指定配置文件启动
	supervisord -c /etc/supervisor.conf
6.通过supervisorctl管理任务
	supervisorctl -c /etc/supervisor.conf
7.supervisor管理django进程的命令
    > stop luffycity_uwsgi
    > reload luffycity_uwsgi  
    > restart luffycity_uwsgi
    > stop all  停止所有的进程
    注意：显示用stop停止掉的进程，用reload或者update都不会自动重启。
8.配置文件具体参数
supervisord.conf配置文件参数解释
[program:xx]是被管理的进程配置参数，xx是进程的名称
[program:xx]
command=/opt/apache-tomcat-8.0.35/bin/catalina.sh run  ; 程序启动命令
autostart=true       ; 在supervisord启动的时候也自动启动
startsecs=10         ; 启动10秒后没有异常退出，就表示进程正常启动了，默认为1秒
autorestart=true     ; 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启
startretries=3       ; 启动失败自动重试次数，默认是3
user=tomcat          ; 用哪个用户启动进程，默认是root
priority=999         ; 进程启动优先级，默认999，值小的优先启动
redirect_stderr=true ; 把stderr重定向到stdout，默认false
stdout_logfile_maxbytes=20MB  ; stdout 日志文件大小，默认50MB
stdout_logfile_backups = 20   ; stdout 日志文件备份数，默认是10
; stdout 日志文件，需要注意当指定目录不存在时无法正常启动，所以需要手动创建目录（supervisord 会自动创建日志文件）
stdout_logfile=/opt/apache-tomcat-8.0.35/logs/catalina.out
stopasgroup=false     ;默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程
killasgroup=false     ;默认为false，向进程组发送kill信号，包括子进程

uwsgi:

https://www.cnblogs.com/pyyu/p/9481344.html

https://blog.csdn.net/dongfei2033/article/details/81124465 这里还有一个虚拟机关于 ip 不显示的问题。

这个东西很麻烦，其中还包括子网掩码很多东西搞不懂，如果只是需要连接本机的 ip，你直接该就行了。

关于下面图片里面的 to 就是你这次访问的路由，form 你来的路由，next 就是 this.$router.push 函数。

写完之后，需要打包上线。
前段：npm run build