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
5.tree mysite/ 查看django项目目录结构
yum install tree -y
6.查找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 # 激活虚拟环境
deactivate # 退出虚拟环境
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:
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@'%';
# 给予root用户权限授予远程登录的命令
grant all privileges on *.* to root@'%' identified by 'xiaoming';
此时可以再windows登录linux的数据库
mysql -u xiaoming -p -h 192.20.178.32
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
0.设置后台启动
修改daemonize no 将no 改为yes 就可以使redis后台运行
redsi-server redis.conf 通过配置文件启动redis
这个时候使用windows的python脚本连接这个redis发现连不上
# 想要其他人访问你的redis
ps -ef | grep redis
kill redid_pid 关闭redis
之后修改vim redis.conf， 内容如下：
1. 修改redis.conf中bind参数，让redis可以远程访问
bind 127.0.0.1 默认是这个，只能本机方位，改为0.0.0.0 让所有人访问
2.修改redis.conf中port端口，防止黑客攻击
port 6379 给为 6377 随意改一个端口，不想让别人知道
3.修改redis.conf中 requirepass,设置redis密码，防止黑客攻击
设置redis的密码进行登录验证
redis.conf 中 requirepass 默认是被注释了的 随便设置一个值requirepass 1 这个1就是我的密码
redsi-server redis.conf 通过这个配置文件启动，配置文件中设置了很多我们需要的参数
4.通过新的端口和密码登录redis
redis-cli -p 6377
登录后
auth 密码
redis还支持交互式的参数，登录数据库
redis-cli -p 6377 -a 1 这种方式不安全，其他人可以使用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功能
# AOF持久化配置，两条参数 vim myredis.conf
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 6379 info # 查看详细信息，其中每一#注释就是一个字典的key
redic-cli -p 6379 info Replication # 查看Replication这个key的值
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
# 写入下面内容
port 26379
dir /var/redis/data/
logfile "26379.log"
sentinel monitor myredis(自己定义,就是在哨兵文件中给主库起一个别名，主库需要设置) 127.0.0.1 6379 2（这个参数的意思是几个哨兵同意可以换主人）
sentinel down-after-milliseconds myredis 30000
sentinel parallel-syncs myredis 1
sentinel failover-timeout myredis 180000
# 内容
prot 26379
dir /var/redis/data/
logfile "26379.log"
sentinel moitor myredis 127.0.0.1 6379 2
sentinel dowm-after-milliseconds myreids 300000
sentinel parallel-syncs myredis 1
sentinel failover-timeout myreids 1800000
# 快速生成其他两个配置文件（仅仅只是配置文件端口的不同）
sed 's/26379/26380/g' redis-sentinel-26379.conf > redis-sentinel-26380.conf
sed 's/26379/26381/g' redis-sentinel-26379.conf > redis-sentinel-26381.conf
3.添加后台运行参数，使得哨兵服务进程在后台运行
echo "daemonize yes" >> redis-sentinel-26379.conf
echo "daemonize yes" >> redis-sentinel-26380.conf
echo "daemonize yes" >> redis-sentinel-26381.conf
4.启动redis-sentinel
redis-sentinel redis-sentinel-26379.conf # 启动
sed -i 's/mymaster/myredis/g' redis-sentinel-26379.conf # -i参数直接更改文件
ps -ef | grep sentinel # 查看哨兵进程起来没有
5.查看哨兵的通信信息
redis-sentinel -p 26379 info sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.119.10:6379,slaves=2,sentinels=3
#看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是192.168.119.10:6379，有两个从节点，3个哨兵
# 进行测试哨兵是否真的可以起作用
6.杀死一个redis主库，6379节点，等待30s以内，检查6380和6381状态
redis-cli -p 6380 info replication
redis-cli -p 6381 info replication
redis-cli -p 63791 info replication
kill 6379主节点
如果切换主从身份之后，（原理就是更爱redis的配置文件，切换主从身份）
7.恢复6379节点的数据库，查看是否将6379添加为新的从节点数据库
redis-server redis-1.conf
redis-cli -p 6379
redis-cli -p 6379 info replication # 6379端口主从信息
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=41814,lag=1
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 > redis-7001.conf
sed 's/7000/7002/g' redis-7000.conf > redis-7002.conf
sed 's/7000/7003/g' redis-7000.conf > redis-7003.conf
sed 's/7000/7004/g' redis-7000.conf > redis-7004.conf
sed 's/7000/7005/g' redis-7000.conf > 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> set name chao # 这里在7000端口设置了一个值
-> Redirected to slot [5798] located at 127.0.0.1:7001 # 他讲这个key重定向到了7001端口
OK
127.0.0.1:7001> exit # 这里发现没有切换到了7001，
[root@yugo /opt/redis/src 18:46:07]#redis-cli -c -p 7000
127.0.0.1:7000> ping
PONG
127.0.0.1:7000> keys * # 这个时候查看7000端口的key是空的
(empty list or set)
127.0.0.1:7000> get name # 但是你在获取的时候，他又会重定向到7001获取对应的值
-> 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（自定义格式）;
#默认文件类型
default_type application/octet-stream;
# 日志信息
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;
sendfile on;
# tcp_nopus on;
# keepalive_timeout 0;
# 连接保持多久,保持长连接
keepalive_timeout 65;
# 支持图片gif等等压缩，减少带宽
gzip on ;
#虚拟主机的配置
server{
#监听端口
listen 80;
#域名可以有多个，用空格隔开
server_name www.w3cschool.cn w3cschool.cn;
# 定义编码格式
charset utf-8;
# 定义网页的的访问url
# 比如下面的用户访问格式就是127.0.0.1/av，
location /av{ # 这里的av不写默认访问127.0.0.1，具体ip看你自己的，我这里随便写的一个ip
# root参数定义网页根目录，你的前段页面从哪里读
root html;
# 定义网页的首页页面，网页404就有可能是这里的路径没有配置正确
index index.html index.htm;
}
# 定义错误页面，客户端的错误，就会返回40x系列状态码
errot_page 404 403 /404.html
# 50X系列错误码代表后端代码出错
errot_page 501 500 /404.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地址的服务器，通过凡响的代理我们可以访问的服务器
}
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;
# [权重]
# server 172.20.110.100 weight=100; # 权重算法
# erver 172.20.110.101 weight=1;
[ip_hash] # 根据一个哈希算法进行的
ip_hash;
server 172.20.110.100;
server 172.20.110.101;
}
# 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;
# [权重]
# server 172.20.110.100 weight=100; # 权重算法
# erver 172.20.110.101 weight=1;
[ip_hash]
ip_hash;
server 172.20.110.100;
server 172.20.110.101;
}
---------------------------------------------------------------------------
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的参数，生成干净隔绝的环境
# 绝对要记住下面的路径是你自己的，需要改成自己的，不要粘贴过去找不到会报错
export VIRTUALENVWRAPPER_PYTHON=/opt/python347/bin/python3 #指定python解释器
source /opt/python34/bin/virtualenvwrapper.sh #执行virtualenvwrapper安装脚本
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
2.安装node模块，打包node项目
cd cd 07-luffy_project_01/
npm install
# 这里有一个问题，我们得本地测试的时候是访问127.0.0.1，需要修改代码里面的ip
npm run build # 生成一个dist文件夹，整个前段项目的内容和index.html都ok了
3.等待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
浙公网安备 33010602011771号