1. 服务器有哪些硬件?
主板
内存
cpu
硬盘
显卡
声卡
网卡
2. 内存，CPU，硬盘的作用?
内存: 负责临时存储你所打开的程序的暂时存储使用，不管什么程序都需要在内存里才能够运行，特点存储速度快
CPU: 电脑的主芯片，就像人的大脑，数据的交换在这里进行，所以，它功能越好，交换越快
硬盘: 负责存储你的数据和资料
3. 服务器常见品牌？
DELL, HP, IBM, 浪潮, 联想
4. 操作系统的作用？
有效的控制硬件资源的运作，并且提供电脑运行所需的功能
5. 开源软件的特性，以及开源许可的协议
开源软件的特性:
低风险: 使用闭源软件无疑把命运交付给他人，一旦封闭的源代码没有人来维护，你 将进退维谷; 而且相较于商业软件公司，开源社区很少存在倒闭的问题。
高品质: 相较于闭源软件产品，开源项目通常是由开源社区来研发及维护的，参与编写、维护、测试的用户量众多，一般的 bug 还没有等爆发就已经被修补。
低成本: 开源工作者都是在幕后默默且无偿地付出劳动成果，为美好的世界贡献一份力量，因此使用开源社区推动的软件项目可以节省大量的人力、物力和财力。
更透明: 没有哪个笨蛋会把木马、后门等放到开放的源代码中，这样无疑是把自己的罪行暴露在阳光之下。
开源许可的协议:
复制自由
传播自由
收费传播: 开源软件都是通过对用户提供有偿服务形式来盈利
修改自由: 开发人员允许增加和删除软件的功能，但是还必须遵循 GPL 许可协议
6.linux 优点
Linux 高效和灵活，Linux 同时具有多任务、多用户的能力，支持多线程，多 CPU。
Linux 包括了文本编辑器，高级语言编译器，以及图形用户界面登应用软件，当然绝大多数服务器都是使用命令行，文本模式操作 Linux 的。
Linux 遵循 GNU 通用公共许可协议，属于自由软件，用户不需要支付费用就可以获得系统和系统源代码，无偿使用且自由传播。
Linux 具有很高的系统稳定性和可靠性。
具有很高的系统安全性
众多业界厂商支持，如 IBM、Oracle、Intel、HP、Google 等
有完善的数据库平台，包括 Oracle、DB/2、Sybase、MySQL、PostgreSQL 等。
有完善的图形化用户界面，包括 GNOME、KDE 等。
有完善的开发平台，包括 C/C++、Java、Python 等。
7. 说出常见的 linux 发行版
centos
redhat
SUSE
ubuntu
8. 用虚拟机学 linux 的好处是？
利用虚拟机搭建 Linux 学习环境简单方便、容易上手，最重要的是虚拟机模拟的 Linux 和真实服务器几乎无区别

运维
啥也干 (helpdesk)，桌面运维工程师，维修笔记本，修电脑，维护路由交换机，插网线
维护服务器的
超强性能的一台主机,100G~500G 内存
运维开发工程师
运维 + 开发
运维自动化
- 运维人员，一个人要维护上百台服务器
CMDB 运维资产管理平台
- 资产收集，通过 web 界面，展示公司所有服务器相关信息
-
堡垒机
- 记录 linux 服务器登录人员的所有操作记录
- 记录登录人员的 ip，身份信息等等
监控平台
- 监控服务器健康状态
测试
找 bug，和后端打架的
后端开发
咱们这群精英
dba
专业维护 mysql 数据库的
UI (设计师)
画图，网站设计，精通 PS,AI 等软件
爬虫工程师
爬数据
架构师（技术组长）
画框架，精通 python，精通 linux，精通网络，制定你公司技术栈架构的人
BOSS
发工资，骂人的那个

笔记本组成；
外观组成:
屏幕
键盘
触控板
摄像头
USB
音箱
散热器
电源
光驱 - 放光盘 DVD
网口
HDMI 视频接口
VGA
type c
雷电口
3.5 耳机孔

服务器呆的环境：
1. 本公司有钱，自建机房, 自己的服务器自己管
2. 服务器托管，找北京的大型机房托管公司，我公司的服务器，放在别人家运行，我交钱
- 世纪互联
3. 小型公司，使用云服务器，我公司不需要维护服务器，只需要进行业务运转即可
- 阿里云
- 腾讯云
- 华为云
- 亚马逊云

软件开发目录规范
bin
src
conf
static
lib
log
db
core
README.MD
docs

Linux 发行版
redhat 发行版，收费版的 linux
- 提供了资格认证，考试
RHCSA
红帽系统管理员，熟悉 linux 命令，相关系统配置
RHCE
红帽认证工程师，熟悉 linux 常用服务器配置，nginx、ftp、samba、等等
RHCA
红帽架构师

SUSE -linux
德国版 linux，常用于电信，移动，支付服务器
你到了公司里，服务器系统只有几种：

centos
redhat 这俩一样的用法

suse 单独学习

ubuntu 单独学习

 

安装 windows：
1. 准备 U 盘安装 windows，傻瓜操作
2. 准备一个机器，安装到 c 盘

安装 / 使用 Linux 的方式：
1. 下载操作系统 www.centos.org centos-7.3.iso 镜像文件 DVD 光盘刻录了操作系统，USB 写入系统
2. 安装 linux
- 准备一台机器，安装 linux
- 成本大，只能装一个系统
- 直接安装 linux，去掉 windows
- 只能一个
- 安装双系统，一个 win 一个 linux
-windows+vmware+linux
vmware 是一个虚拟化产品的软件，提供了多个操作系统安装的功能
vmware 就是一个虚拟的主机，并且可以虚拟出多个主机
vmware workstation 个人学习版，假设能运行 5 个虚拟机
centos
redhat
ubuntu
macos
vmware 使用方便，并且可以运行多个操作系统
vmware 软件是吃物理机的资源的
根据你物理机资源大小，可控的虚拟机数量
vmware esxi 企业版虚拟化
256G 的内存的服务器
一台 dell 的服务器，虚拟化出了 60 多个 redhat
物理机 +windows+vmware+docker

vmware 软件提供了快照功能
假设我装机 ok 后，系统初始化 ok 后，做一个快照

vmware 出现不支持 vt 虚拟化的解决办法：
1. 你的主板的 cpu 不支持 VT，禁用了 VT 这个技术
2. 找到你对应的笔记本型号，的 BIOS 设置，可能是 F1\F2\F10\F12

linux 支持 7 个终端：
通过 ctrl+alt +f1-f7
linux 有 7 个终端，f1 是图形化，f2-f7 是命令行终端

远程连接 linux：
1. 通过 xshell 客户端软件，登录 linux
2. 知道 linux 的 ip 地址，通过 ip 地址连接

局域网
192.x.x.x
192.168.12.1
192.168.12.2
192.168.12.3
192.168.12.xx
192.168.12.xx
10.x.x.x
172.x.x.x

桥接模式：
假设我们的局域网段是 192.168.12.xx
相当于在局域网内，添加一台电脑，占用一个局域网的 ip
宿主机是：192.168.12.74
小何同学：192.168.12.55
Linux 主机:192.168.12.85，分配一个 192.168.12.85 网段的 ip

NAT 网络模式：
就是在你宿主机的 ip 网络中，通过网络地址转换技术（NAT），分配一个私有局域网 (可自定义的,192/10)
宿主机是：192.168.12.74
Linux 网络地址转换： 192.x.x.x.
10.x.x.x
我通过 nat 技术，给 linux 分配一个私有局域网，nat 网络地址转化技术可以解决的问题
1.ip 地址不够用，0~255
2. 解决 ip 可能冲突的问题
网络连接方式有 2 种：
1.dhcp，动态获取 ip
2. 静态 ip，写在配置文件的 ip

3. 如何安装 linux
- 通过 vmware 这个虚拟化软件，安装 linux 且学习
- 准备一个云服务器
- 这些服务器准备的步骤，是不需要自己来做的
- 在公司里，都有运维人员配置好了
- 配置一个 linux 上网方式
- 桥接 (dhcp) 动态获取一个 ip 地址
-nat
-host only
4. 如何远程连接 linux 服务器
- 咱们准备一个 xshell 客户端工具，用于连接 linux
- 通过 linux 一个命令登录 linx
ssh root@ip
ssh root@192.168.12.85
5.linux 管理网络的命令
1. 在系统刚装好的时候，默认可能没有启动网卡
ifup 网卡名字 (ens33) #启动网卡
ifdown 网卡名字 #关闭网卡
2. 管理网络配置的文件
/etc/sysconfig/network-scripts/ #网络配置相关信息文件夹
可以通过 vi，打开这个网卡文件，修改一个参数使得开机加载网卡
onboot=yes
网卡对应的文件叫做
ifcfg-ens33 大家的网卡配置文件可能与我不一样
3. 管理网络的一个服务脚本文件
/etc/init.d/network stop #停掉 IP
/etc/init.d/network start/stop/restart 对网络服务进行启停 / 重启
4. 查看 linux ip 地址信息
ip addr show
ifconfig
Linux 基本命令学习：
查看当前位置，打印当前工作目录
pwd (print work directory)
得到一个反
馈结果
/root
Linux 下，文本是白色的，文件夹是蓝色的

对文件 / 文件的增删改查：
增
mkdir 创建文件夹
mkdir hellos14 #创建一个名为 hellos14 的文件夹
创建文件
touch test.txt
touch test.py
touch test.java
touch test.go

删
rm (remove)，删除文件的命令
rm 要删的文件
rm test.txt
rm -i test.txt
-i 参数是删除文件要提醒
rm -i test* #删除所有以 test 打头的文件
rm -r 递归删除文件夹

#友情提醒，实验之前，做好快照
linux 之作死命令
rm -rf /* #删除 linux 底下所有东西，然后收拾东西辞职
#vmware 提供了快照功能

rmdir 命令只能删除空文件夹

linux 善用 tab 键进行命令补全
既可以补全命令
又可以补全文件

Linux 的帮助手册，查看命令详细用法
man rm
man ls

改
mv 命令，移动，改名

mv 旧文件名 新文件名

#把 test 文件夹改为 prod 文件

mv test prod

cp （copy）复制命令
cp 文件名 新文件名
cp test.py test.py.back
cp -r test test2 #递归拷贝文件夹，把 test 文件下所有子孙后代都 复制一份 为 test2
复制文件夹:
cp -r chenwei/ chenwei1111
cp -r -p chenwei/ chenwei2222

区别: 前者所有时间戳都改变, 后者不改变, 但是后者的最近一次访问 touch 的时间改变了
查
ls 查看命令，查看文件夹的命令
ls 操作对象
ls /root
ls -l /root 显示 /root 文件夹下详细信息
ls -la
-l 显示详细信息
-a 显示隐藏文件 / 文件夹
ls -la /root/ #显示 /root 文件下所有文件和文件夹
drwxr-xr-x. 2 root root 37 Nov 28 14:58 .
dr-xr-x---. 6 root root 4096 Nov 28 14:53 ..
-rw-r--r--. 1 root root 0 Nov 28 14:58 test.py
-rw-r--r--. 1 root root 0 Nov 28 14:58 test.txt
这个 . 代表当前目录
这个 .. 代表上一级目录

cd （切换目录）
cd /root/helloS14 #切换目录到 /root/helloS14 文件夹中
cd 命令只能进入文件夹，不能进入文本文件

查看文本内容
cat 命令，查看文件信息

cat 文件

cat first.py

 

#修改密码的 linux 命令
passwd 用户名
passwd root #输入两次密码

vi 编辑使用笔记：
1. vi first.py #打开文件
2. 此时你进入了一个叫做命令模式的状态，等待输入命令，一般会输入 i/o/a
i 是 insert 插入的意思
o 是在光标所在行的下一行写入信息
3. 输入 i 之后，进入编辑模式，就可以写入代码了

4. 按下 esc，退出编辑模式，此时回到了命令模式，输入 :wq! 退出且写入文本信息
: 是 进入底线命令模式的参数
w 是写入的意思
q 是退出的含义
! 强制性的含义

远程登录服务器的命令
ssh root@192.168.12.85

redhat123 #输入 root 的密码

Linux 查看用户登录终端的命令
w #此命令记录用户登录的，用户身份，来源 ip

1. 如果你是通过 xshell 直接登录我的这个机器，那么我记录的 ip 的就是你 windows 的 ip 地址
2. 如果你是已经登录了 linux，然后通过你的 linux，再 ssh 登录我的机器，那么我记录的就是你 linux 的 ip

Linux 下查看用户身份信息的命令

whoami

查看终端信息的命令
tty

 

#更改 linux 主机名
hostnamectl set-hostname s14linux

#退出 linux 登录会话的命令
logout

 

#xshell 的快捷命令
#清屏命令 clear ctrl + L
#快速退出 ctrl + d 等同于 logout
#快速登录 ctrl + shift + r
#关机命令
poweroff

 

day103Linux
linux 的绝对路径，相对路径
绝对路径
/ 小明 / 前面的同学 / 前面的同学 / 小赵
相对路径 (小明为相对路径)
../ 小明 / 前面的同学 / 前面的同学 / 小赵
示例:
cd buy # -> 到 buy 文件夹下
mkdir zhifubao # 新建 zhifubao 文件夹
cd zhifubao # 到 zhifubao 文件夹下
绝对: mkdir /root/buy/taobao # 在 buy 文件下再建一个 taobao 文件夹
相对: mkdir ../jingdong # 在 buy 文件下再建一个 jingdong 文件夹
cd - 返回上一次的路劲,(两个路劲反复跳转)
cd ~ 跳转到 root 目录下 /root
ls -la 等同于 ll -a #显示 /root 文件下所有文件和文件夹
mkdir -p news14/python/linux #新建文件夹下的文件下的文件夹.....

windows 的环境变量（PATH）
path 能做什么？
能从 path 里面定义的路径去寻找，我们输入的命令
当我输入 python3 的时候，通过优先查找顺序，找到自定义的 path 中是否有 python3 这个解释器
windows 环境变量:
C:\Python27\;
C:\Python27\Scripts;
E:\Python 环境 \Python36\Scripts\;
C:\Program Files\Redis;
Linux 的环境变量（PATH）:
echo $PATH
/usr/local/sbin:
/usr/local/bin:
/usr/sbin:
/usr/bin:
/root/bin:
/
白色: 文件,(文件权限 -) 蓝色: 文件夹,(文件权限 d) 绿色: 可执行的文件 (命令)
新建用户
useradd chenwei 用户名
passwd chenwei 密码
root 用户 (超级用户): [root@cwlinux ~]#
chenwei 用户 (普通用户):[chenwei@cwlinux ~]$
在当前目录下创建 a,c 文件夹,a,c 文件夹下分别创建 b,d 文件夹
mkdir -p a/b c/d

安装 tree 命令: 以树状图形式直观的查看 linux 目录信息
yum install tree -y
tree
同时创建多个文件夹
mkdir -p chenwei/{大神, 牛逼, 厉害}

每次执行 touch test.py 命令, 都会修改文件的时间戳 ls-l 查看

查看文件和文件夹的详细信息:(stat 文件 / 文件夹名)
stat test.py
更改文件和文件夹的时间戳 ("11291611"-->11 月 29 号 16 时 11 分)
touch -t "11291611" test.py
存放用户配置文件信息:/etc/
显示行号:cat /etc/passwd -n

显示空行 ($ 代表空行和行结尾):cat test.py -En

特殊符号
输入 / 输出 重定向符号
1.>> 追加重定向，把文字追加到文件的结尾
echo "789456" >> test.py
2.> 重定向符号，清空原文件所有内容，然后把文字覆盖到文件末尾
echo "" > test.py
cat 与重定向输出符结合使用
cat >> test.py << EOF
> 让我掉下眼泪的
> 不是 python 的难
> 让我依依不舍的
> 是怼你的温柔
> EOF
cat test.py
------------------------------------
ip addr > /tmp/network.txt #标准输出重定向 把命令执行结果信息，放入到文件中
3. 通配符
ls -l /etc/us*

cat 不适合读大文件,more 命令会分页去读
more /etc/passwd
#问 linux 底下有多少查看文本的命令
cat, more, less, head, tail
默认取文本的前十行
head /etc/passwd
前 5 行
head -n 5 /etc/passwd
后 10 行
tail /etc/passwd
find:
查找文件:
find /opt -name settings.py
查找所有:
find / -name *.py
找 - 根目录 -d(文件夹) 类型 - 找的名字
find / -type d -name usr
settings.py
ALLOW_HOST=['*']
管道命令:
查看全部进程
ps -ef
搜索进程
ps -ef | grep test.py
grep:
查询
grep "root" psinfo.txt
查询文件中的 allow_host, -i 不区分大小写
grep -i "allow_host" settings.py
grep -i "host" settings.py
查询文件中除了 allow_host 的其他内容
grep -i "allow_host" settings.py -v
查询网卡配置文件 ONBOOT="yes"
grep -i 'onbo' /etc/sysconfig/network-scripts/ifcfg-ens33
sed: 替换工具
sed 's/ONBOOT="yes"/ONBOOT="no"/' /etc/sysconfig/network-scripts/ifcfg-ens33
还没有修改成功,, 没有生效, 没保存
vim /etc/sysconfig/network-scripts/ifcfg-ens33
所以:
sed 's/ONBOOT="yes"/ONBOOT="no"/' /etc/sysconfig/network-scripts/ifcfg-ens33 -i
vim /etc/sysconfig/network-scripts/ifcfg-ens33
持续监测文件:
tail -f test.py
在另一个回话中追加数据
echo "123" >>/root/test.py
alias 别名功能
当你输入 rm -rf / 的时候，提示你，禁止使用 rm
alias rm="echo 你可别用 rm 了"
取消禁用 rm
unalias rm
找到 python 在那个环境变量里
which python
scp 命令: 传递文件
scp ./test.py.back root@192.168.12.128:/opt/
另一台机器查看
ls /opt/
传递文件夹
scp -r -v chenwei1111 root@192.168.12.128:/home/
远程下载文件夹
scp -r root@192.168.12.128:/root/chao ./

du 命令: 显示目录或文件的大小
所有文件的大小:du
查看文本大小:du testdu.txt -h
统计根文件多大:du -sh .(s: 合计,h:kb 单位显示)
统计所有的日志大小:du -sh /var/log/
统计磁盘空间大小:df -h
top 命令: 用于动态监视进程活动与系统负载信息
两大板块: 进程和系统负载
系统负载:
第一行: 系统时间等
第二行: 进程信息
第三行:cpu 信息
第四行: 内存信息
第五行:swap 信息
可视的查看:
free -m 查看内存大小
chattr 命令:
给文件加锁
chattr +a test.py
查看锁
lsattr
减锁
chattr -a test.py
时间命令:
查看软件时间
date
查看硬件时间
hwclock
同步为软件时间
hwclock -w
同步为软件时间
hwclock -s
Ntp 时间服务器:linux 下的时间服务器叫做 ntp 服务, 是用于时间同步的 客户端命令
ntpdate -u ntp.aliyun.com
wget 命令: 在线下载资源
wget http://pythonav.cn/av/girlone.jpg
爬资源:
weget -r -p http://www.luffycity.com
不允许爬的资源:
vim robots.txt
命令重启机器:reboot
关机命令:poweroff
读取 /etc/passwd 的内容 -- 重定向到 /tmp/passwd.txt
cat /etc/passwd > /tmp/passwd.txt
# yum install lrzsz -y #可以很方便的，在 windows 和 linux 之间，拖拽文件

1. 查看 linux 的 path 变量
echo $PATH
2. 简述 linux 的文档目录结构
/dev 存放抽象硬件
/lib 存放系统库文件
/sbin 存放特权级二进制文件
/var 存放经常变化的文件
/home 普通用户目录
/etc 存放配置文件目录
/boot 存放内核与启动文件
/bin 存放二进制文件 (可执行命令)
/usr 存放安装程序 (软件默认目录)
/mnt 文件挂载目录 (U 盘. 光驱)
/root 特权用户目录
/opt 大型软件存放目录 (非强制)
3. 递归创建文件夹 /tmp/oldboy/python/{alex,wusir,nvshen,xiaofeng}
mkdir -p /tmp/oldboy/python/{alex,wusir,nvshen,xiaofeng}
4. 显示 /tmp/ 下所有内容详细信息
stat /tmp/
ls -l /tmp/
5. 简述 / ~ - 的含义
/ 根目录
~ 当前 linux 登录用户的家目录
- 上次访问目录
6. 请简述你如何使用 vi 命令
1. vi first.py #打开文件
2. 此时你进入了一个叫做命令模式的状态，等待输入命令，一般会输入 i/o/a
i 是 insert 插入的意思
o 是在光标所在行的下一行写入信息
3. 输入 i 之后，进入编辑模式，就可以写入代码了
4. 按下 esc，退出编辑模式，此时回到了命令模式，输入 :wq! 退出且写入文本信息
: 是进入底线命令模式的参数
w 是写入的意思
q 是退出的含义
! 强制性的含义
7. 查看 /etc/passwd 的内容并且打印行号
cat /etc/passwd -n
8. 查看文本有哪些命令？
cat, more, less, head, tail
9.linux xshell 常用快捷键？
tab: 补全命令
清屏命令 clear ctrl + L
快速退出 ctrl + d 等同于 logout
快速登录 ctrl + shift + r
10. 如何用 echo 清空一个文件？
echo > test.py
11. 复制 /tmp/ 下所有内容到 /home，在修改文件前，先拷贝一份，防止内容被破坏
echo /tmp/ >> /home/tmp/
cp -r /tmp /home
12. 重命名 test.py 为 my.py
mv test.py my.py
13. 强制删除 /tmp 下内容
rm -rf /tmp/*
14. 找到服务器上的 settings.py
find / -name settings.py
15. 找到 /etc 下的网卡配置文件，提示网卡配置文件名是 ifc 开头
find /etc -name 'ifc*'
这里题目，请先 cp /etc/passwd /tmp/ 拷贝文件
16. 过滤出 /tmp/passwd 下有关 root 的信息
grep -i "root" /tmp/passwd
17. 过滤出 /tmp/passwd 下除了 /sbin/nologin 的信息，且打印行号
grep -i "/sbin/nologin" /tmp/passwd -v -n
18. 查看 /tmp/passwd 前 25 行
head -n 25 /tmp/passwd
19. 查看 /tm/passwd 后 3 行
tail -n 3 /tmp/passwd
20. 不间断打印 /var/log/py.log 的信息
tail -f /var/log/py.log
23. 配置 rm 别名为“禁止你用 rm，谢谢”，然后取消别名
alias rm="echo 禁止你用 rm，谢谢"
unalias rm
24. 将服务器 1 的 /tmp/my.py 远程传输到服务器 2 的 /opt/ 目录下
scp /tmp/my.py root@192.168.12.128:/opt/
25. 将服务器 2 的 /opt/test.py 拷贝到服务器 1 的 /home 目录下
scp -r root@192.168.12.128:/root/chao ./
26. 统计 /var/log/ 文件夹大小
du -sh /var/log/
27. 简述 top 的常见参数
用于动态监视进程活动与系统负载信息
两大板块: 进程和系统负载
系统负载:
第一行: 系统时间等
第二行: 进程信息
第三行:cpu 信息
第四行: 内存信息
第五行:swap 信息
28. 给 settings.py 加锁，禁止删除
chattr +a settings.py
29. 同步服务器时间到 ntp.aliyun.com
ntpdate -u ntp.aliyun.com
30. 下载 http://pythonav.cn/xiaobo.jpg 图片
wget http://pythonav.cn/xiaobo.jpg
day104Linux

今日内容：

#查看操作系统详细信息
cat /etc/os-release
#查看系统版本信息 (简短信息)
cat /etc/redhat-release
CentOS Linux release 7.4.1708 (Core)
#查看内核版本号
uname -r
3.10.0-693.el7.x86_64
#查看内核所有信息
uname -a
#查看系统多少位
uname -m
x86_64

#公司的一个技术组的权限分配

#运维组 root 用户，root 用户组，这是最高权限的组部门

#前端组 qianduan1 qianduan2 前端组

#后端组 kangcheng xiaoming 后端组

#查看用户身份权限
id 用户名 (id root)
uid=0(root) gid=0(root) groups=0(root)
#root 用户创建普通用户，普通用户的 uid 从 1000 开始
useradd chenwei
id chenwei
uid=1000(chenwei) gid=1000(chenwei) groups=1000(chenwei)
#创建普通用户 useradd 创建用户，同时创建用户组，再创建用户家目录
tail /etc/group
#useradd 用户添加命令
创建用户的同时，创建用户组
会在 /etc/passwd 中添加用户
在 /etc/group 中添加用户组

#更改用户密码 passwd

#普通用户，更改自己的密码
passwd #且不能指定用户，直接直接输入，更改自己的密码
1. 输入正确的当前用户密码
2. 输入新密码
3. 确认新密码
#查看创建的文本信息 (最后一行的用户)
tail -1 /etc/passwd

#普通用户权限 (停止 ip, 必须输入 root 管理者的密码)
/etc/init.d/network stop
#linux 切换用户身份
su 命令:su - 用户名
#root 用户可以随意切换普通用户，不需要密码
su chenwei
#普通用户切换 root，必须输入密码
su - root #输入的是 root 的密码
sudo su - #输入当前用户的密码，并且这个用户得在 /etc/sudoers 中才能成功登陆 root
#退出当前用户
exit

#存放用户身份信息的文件
/etc/passwd
#存放用户组的文件
/etc/group
#存放用户密码的文件
/etc/shadow

#创建用户组
groupadd 组名
#查看所有用户组
tail /etc/group
#强制删除用户 aaa 及 aaa 的家目录
userdel -rf aaa

#Linux 使用 root 身份去执行命令，以解决权限不够的问题
1. 修改 /etc/sudoers 文件，添加想要执行 sudo 命令的用户
2.vim /etc/sudoers
3. 写入
## Allow root to run any commands anywhere
root ALL=(ALL) ALL
chenwei ALL=(ALL) ALL #在这里写入你想添加的用户
xiaolv ALL=(ALL) ALL
4. 此时就可以通过 sudo 命令。给普通用户添加超级权限
sudo ls /root /

#Linux 文件权限 (- 代表文件) ls-l 查看
r 可读 可以对文件 读取 4
w 可写 可以写入文件内容 2
x 可执行 可以执行这个文件 1
- 没有权限
- rw-(user) r-- (group) r--(others)
文件类型 user 的权限 group 的权限 others 的权限
普通文件 可读，可写 可读 可读

#文件夹权限 (d 代表文件夹)
r 可以对此目录执行 ls 列出所有文件
w 可以在这个目录创建文件
x 可以 cd 进入这个目录，或者查看详细信息
#文件夹的权限 d
d rwx r-x r-x. 3 root root 20 Nov 29 17:21 python

#软连接 l
#权限分配，linux 有三个用户身份，可以设置权限，分别是：
user 所属用户
gourp 所属用户组
other 谁也不属于，其他人的身份

#更改文件 / 文件夹的权限
chmod 命令去更改文件权限

#chmod 对谁操作 加减什么权限 对象
语法是： u 代表 user
g 代表 group
o 代表 others
chmod u+rwx(4+2+1) 文件
chmod g+rwx 文件
chmod o+rwx 文件
#转化成 ↓↓↓↓这个写法
chmod 7 7 7 文件 #给文件所有的用户身份，添加 可读可写可执行

#文件夹 7(mjj) 7(mjj) 7(others)

#一个一个用户的去改
chmod u-wx test
chmod g-r
chmod o-w test

#更改文件权限
chmod 755 mjj.txt
-rwx r-x r-x
chmod 465 mjj.txt
-r-- rw- r-x
chmod 5 6 7 mjj
d r-x rw- rwx

#linux 修改文件所属用户，所属组
chown 用户身份 对象
chgrp 组身份 对象
-rw-r--r--. 1 root root 0 Nov 30 19:34 test.txt
#你必须确认有这个用户存在，有这个组存在
/etc/passwd 里面是否有 chenwei
grep 'chenwei' /etc/passwd
grep 'chenwei' /etc/group

chown chenwei test.txt

chgrp chenwei test.txt
-rw-r--r--. 1 chenwei chenwei 0 Nov 30 19:34 test.txt

#更改用户所在的 组
id aaa
uid=1003(aaa) gid=1003(aaa) groups=1003(aaa)

usermod -g root aaa
uid=1003(mjj) gid=0(root) groups=0(root)

#linux 创建快捷方式
ln -s 目标文件 当前快捷方式
ln -s /opt/canglaoshi ./xxx
当前目录下会有一个 xxx 的快捷方式

#/opt/python3/bin/python3.6

#想要快捷的输入 python3.6 就指向 /opt/python3/bin/python3.6

#思路
1. 把 #/opt/python3/bin/python3.6 这个 python3.6 这个解释器，软连接到 path 路径下
2. ln -s /opt/python3/bin/python3.6 /usr/bin/python3
3. 直接输入 python3，就会执行 /opt/python3/bin/python3.6

#不用软连接，通过添加 path 的方式，直接使用 python3.6
思路：
1. 肯定是把 /opt/python3/bin/python3.6 这个文件夹的路径，添加到 path 中
2. 当我输入 python3.6 的时候，系统会通过 path 中指定的路径，找到 python3.6

解决方案：
[root@localhost opt]# echo $PATH
#path 环境变量，放的是目录绝对路径
/usr/local/sbin:
/usr/local/bin:
/usr/sbin:
/usr/bin:
/root/bin:
/opt/python3/bin

#linux 命令提示符更改，PS1 变量
\h　　主机名第一个名字
\t　　时间 24 小时制 HHMMSS
\W　　利用 basename 取得工作目录名
\w　　完整工作目录

#linux 变量配置一次，退出会话后失效
PS1='[\u@\h \w \t]\$'

#linux 的全局环境变量配置文件
vim /etc/profile
PS1='[\u@\h \w \t]\$'
logout
连接

#linux 解压缩
#Linux 压缩文件，都调用 tar 命令

tar 参数 压缩文件
-x 解压缩
-f 指定哪个文件
-c 压缩
-v
下载源码包 -c 断点续传
wget -c https://nginx.org/download/nginx-1.12.0.tar.gz

解包 / 解压:
tar -xf 压缩文件

打包文件 / 压缩文件
tar -cf 压缩后的文件地址 要压缩的内容
tar -cf /home/xiaolaodi.tar 小老弟

#Linux 查看网络端口的命令
netstat -tunlp

#服务器的 ip 地址
127.0.0.1 本机回环地址，代表这个服务器自己，只能自己 ping 同自己
python manage.py runserver 127.0.0.1:8000
192.168.12.85 代表当前机器的 ip 地址
python manage.py runserver 192.168.12.85:8000
在同一个局域网内，192.168.12.xx 这里面的人 都能访问
0.0.0.0 及是 127.0.0.1 又是 192.168.12.85
python manage.py runserver 0.0.0.0:8000
公网 ip 全世界联网的人都能访问
python manage.py runserver 123.206.16.61:8000
#看进程
ps - ef
ps - ef |grep python

#杀掉进程
kill 进程号
#强制杀死进程，无论进程运行在什么状态，一定会杀死，（此命令需谨慎，会影响你服务运转）
kill -9 3124
#杀死进程以及相关进程信息
kilall

nginx master
worker nginx
nginx
nginx

#一次性全部杀掉和 nginx 有关的进程
killall nginx

#linux 的防火墙概念
因为如果你不关防火墙，很可能你后面运行 django、nginx、mysql
防火墙可能会阻挡端口流量的 出口
也会阻挡外来请求的 入口

#selinux iptables firewalld
1. 关闭 selinux
1. 获取 selinux 状态
getenforce
2. 临时关闭 selinux，重启后又会生效
setenforce 0
3. 永久关闭 selinux，写入到 selinux 配置文件
vim /etc/selinux/config
SELINUX=disabled #更改为这个
4. 重启后 selinux 永久关 6 闭

2.iptables (软件防火墙)
1. 查看防火墙规则
iptables -L
2. 清空防火墙规则
iptables -F
3. 关闭防火墙软件，这个服务永久关闭
systemctl stop firewalld
想要编码同一，显示正常的话
都得 server 和 client 端编码统一
查看当前字符集:
echo $LANG
#修改 linux 中文编码支持
export LANG=en_US.utf8
#永久生效修改文件
vim /etc/locale.conf
LANG="zh_CN.UTF-8"
#修改后读取这个文件，使得生效
source /etc/locale.conf

#显示磁盘空间大小
df -h

#更改主机名
hostnamectl set-hostname 新主机名

#DNS 域名解析系统
#在 linux 的配置文件是
cat /etc/resolv.conf
# Generated by NetworkManager
nameserver 223.5.5.5 #域名服务器
nameserver 223.6.6.6
#常见的域名服务器有
8.8.8.8
114.114.114.114
223.5.5.5 #阿里巴巴
223.6.6.6
119.29.29.29 #腾讯的 DNS

dns 在 linux 的解析:
nslookup pythonav.com
去找 dns 服务器的一个服务器地址, 去解析这个域名
去找 /etc/resolv.conf 里面指定的 dns 服务器
Server: 223.5.5.5
Address: 223.5.5.5#53
Non-authoritative answer:
Name: pythonav.com
Address: 47.93.4.198

#编辑配置文件
vim /etc/resolv.conf
#dns 服务器
域名和 ip 的对应关系
一个域名解析一个 ip
多个域名解析到一个 ip
一个域名解析到多个 ip
linux 解析 dns 的命令
nslookup 域名

#linux 的计划任务，软件名叫做 crond
#在一个小本本上写上定时任务，到了什么时间做什么事

crontab 计划任务

* * * * * 命令
分 时 日 月 周
#每小时:
1 * * * * 每小时
#每天晚上 10:30 关机 (注意 24 小时制)
30 22 * * * 关机

#每月的第 7 和第 8 天和第 30 天的零时重启机器
0 0 7,8,30 * * 重启机器

#每月的 1-15 日零点发工资
0 0 1-15 * * 发工资

所有命令一定要用绝对路径来写！

#每分钟执行一次命令
*/1 * * * * 命令
#每 2 分钟执行一次命令
*/2 * * * * 命令

#每小时的 3,15 分执行命令
3,15 * * * * 命令

#在上午 8-11 点的第 3 和第 15 分钟执行
3,15 8-11 * * *

#每晚 21:30 执行命令
30 21 * * *

#周六、日的 1：30 执行命令
30 1 * * 6,0 命令

(crondtab 是必须取 5 个值的交集，必须符合 5 个条件才能正确工作)

#每周一到周五的凌晨 1 点，清空 /tmp 目录的所有文件
0 1 * * 1-5 rm -rf /tmp/*

#每晚的 21:30 重启 nginx
30 21 * * * nginx restart

#每月的 1,10,22 日的 4:45 重启 nginx
45 4 1,10,22 * * nginx restart

#每个星期一的上午 8 点到 11 点的第 3 和 15 分钟执行命令
3,15 8-11 * * 1 命令

#Linux 软件安装的方式
1.rpm 包安装 (需要手动解决软件依赖关系，非常麻烦)
wget https://rpmfind.net/linux/centos/7.5.1804/os/x86_64/Packages/lrzsz-0.12.20-36.el7.x86_64.rpm
1. 下载 mysql-5.5.rpm
通过 rpm 命令去安装软件
rpm -ivh mysql-5.5.rpm
(报错，此 mysql5.5 依赖于其他的软件包，你需要先解决这个依赖问题，才能正确安装 mysql5.5)

2.yum 安装 （其实也是下载 rpm 包然后进行自动安装，自动查找，解决依赖关系）
yum 命令是自动下载软件包
yum 源，就是一个文件夹的概念
这个文件夹叫做 /etc/yum.repos.d/ 只有存放在这个目录中的 xx.repo 文件，
会被识别是 yum 源，才会被 yum instlal 工具 所调用
配置 yum 源的步骤
1. 可以移除默认的 yum 仓库，也就是删除 /etc/yum.repos.d/ 底下所有的.repo 文件（踢出国外的 yum 源）

1. 配置 yum 源，找到阿里云的官方镜像源地址 https://opsx.alibaba.com/mirror
2. 下载 centos7 的 yum 源
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

3. 清空旧的 yum 缓存
yum clean all
4. 生成新的 yum 仓库缓存（这个缓存来自于阿里云的 yum 仓库，便于加速软件下载）
yum makecache
5. 配置一个第三方的 额外仓库源 （epel 源），这个源的作用是，如果阿里云源找不到这个软件，就在这里找
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

此时就可以通过 yum 命令自由的下载软件啦！
yum install redis #这个 redis 就是从 epel 中下载

启动 redis
redis-server
#下载一个 nginx web 服务器软件
yum install nginx -y

#下载好了之后，（通过 yum 安装的软件，都可以通过系统服务管理命令，来管理它的 start/stop/restart）
#启动 / 停止 /nginx 服务
systemctl start/stop/restart nginx
#查看 nginx 服务状态
systemctl status nginx
#

3. 编码编译安装 (可自定制安装软件的需求，以及软件的功能扩展)
1 请问你使用的 Linux 发行版是什么？查看 Linux 发行版的命令是？
CentOS7
红帽系列 linux
cat /etc/redhat-release
ubuntu
cat /etc/os-release

2 请问你公司服务器环境是物理机？还是虚拟化？
必须物理机啊，不过是云服务器
物理机 +vmware esxi(企业版虚拟化软件)
3 请写出操作文件 / 文件夹的基本命令
vim 文件名 编辑文件
cat 文件名 查看文件
rm -rf 文件名 删除文件
mv 旧文件名 新文件名 修改文件
touch 文件 创建文件
mkdir 文件夹名字
ll 文件夹名字 查看文件夹
mv 文件夹名字
rm -rf 文件夹名字 删除文件夹
cd 文件夹 进入文件夹
mv 旧的文件夹 新的文件夹 修改文件夹名
mv 旧的文件夹 已有的文件夹中新的文件夹 移动复制
4 使用 grep 过滤出 /opt/mysite/mysite/settings.py 的 ALLOWED_HOSTS 配置，(请忽略大小写)
grep "ALLOWED_HOSTS" /opt/mysite/mysite/settings.py -i

5 找到目录 /opt/ 下所有的以.py 结尾的文件
find /opt/ -type f -name "*.py"

6linux 如何切换普通用户 oldboy?
su - oldboy

7 如何使用 root 身份执行命令 ls /root/*
sudo ls /root/*
8linux 文件权限的 755,700 是什么意思？转化为 rwx 格式是什么？
rwxr-xr-x, rwx------

9 如何创建 /usr/bin/python3 软连接，链接到 /opt/python34/bin/python3
ln -s /opt/python34/bin/python3 /usr/bin/python3

10 已知 test.py 文件权限是 rwxr--r--，如何修改权限为 rw-rw-rw
chmod 666 test.py

11 解压缩 Python 源码包 Python-3.7.tgz.gz
tar -zxvf Python-3.7.tgz.gz
12 将 /tmp/ 下所有内容压缩成 All_log.tar.gz 并且放到 /home/ 下
tar -zcvf /tmp/* /home/All_log.tar.gz

13 查看 mysql 端口是否存活
netstat -tunlp | grep "mysql"
14 如何查看 django 的进程
ps -sh
25 如何杀死 django 进程
kill 8080
16 在登录 Linux 时，一个具有唯一进程 ID 号的 shell 将被调用，这个 ID 是什么 (B)?
A.NID B.PID C.UID D.CID

17 下面哪个目录存放用户密码信息（B）
A./boot B./etc C./var D./dev

18(D) 不是流行的 Linux 操作系统。
A.Red Hat Linux B.Mac OS C.Ubuntu Linux D.Red Flag Linux

19 用自动补全功能时，输入命令名或文件名的前 1 个或几个字母后按什么键？ (B)
A.【Ctrl】键 B.【Tab】键 C.【Alt】键 D.【Esc】键

20 在 vi 中退出不保存的命令是？(A D)
A. :q B. :w C. :wq D. :q!

21pwd 命令功能是什么? (C)
A. 设置用户的口令
B. 显示用户的口令
C. 显示当前目录的绝对路径
D. 查看当前目录的文件
22 文件权限读、写、执行的三种标志符号依次是 (A)。
A rwx B xrw C rdx D srw

23 某文件的组外成员的权限为只读；所有者有全部权限；组内的权限为读与写，则该文件的权限为 (D)。
A 467 B 674 C 476 D 764

24 改变文件所有者的命令为 (C)。
A chmod B touch C chown D cat

25 当运行在多用户模式下时，可以切换多少虚拟用户终端（ B ）
A、3 B、6 C、12 D、1

26 观察系统当前进程的运行情况的命令是（ C）
A、free B、dmesg C、top D、last

27 如果执行命令 #chmod 746 file.txt，那么该文件的权限是（A）。
A.rwxr--rw-

B.rw-r--r—

C.--xr--rwx

D.rwxr--r—

28 如果您想列出当前目录以及子目录下所有扩展名为“.txt”的文件，那么您可以使用的命令是（A ）。
A.ls *.txt

B.find –name “.txt”

C.ls –d .txt

D.find . “.txt”
day105Linux

今日内容：
安装 python3

1. 下载 python3 源码，选择 3.6.7 因为 ipython 依赖于 >3.6 的 python 环境
wget https://www.python.org/ftp/python/3.6.7/Python-3.6.7.tar.xz
2. 解压缩源码包，去除 xz 后缀
xz -d Python-3.6.7.tar.xz
3. 解压缩源码包，去除.tar 后缀
tar -xf Python-3.6.7.tar
4. 解决编译安装 python3 所需的软件依赖 ******** 很重要
备注：解决这些依赖关系后期才能正常运转 python3.6，
如果不解决，会出现各种报错信息，此时还得重新编译 python3.6
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

5. 开始进行编译安装
分为三部曲
1. 调用源码包路径底下的 configure 这个脚本文件
./configure --prefix=/opt/python36/
2. 执行 make 指令，开始编译 (此步骤还不会生成 /opt/python36 这个文件夹)
#这个编译是个什么鬼？
- 翻译 python 解释器是对代码进行一行一行的翻译，并且转化成机器码去执行
print('hello world')
python 脚本.py
- 编译 ，编译型的语言，在运行代码之前，有一个编译的过程，（将代码，编译转化成一个二进制文件）
- c
- c++
- java
- golang
main.go
fmt.Println('hello world')
go run main.go
go build main.go #编译生成一个可执行命令
- 在 window 底下 生成一个 main.exe
- main
3. make install 安装软件 （此步才是安装软件的过程）
- 才会生成一个 /opt/python36 这个软件安装路径
make install

6. 编译安装 ok，没有报错后，就可以正常使用 python3 了
7. 快捷使用 python3.6 的方式
以下配置方式，二选一，请你选 path 配置
1. 环境变量的配置
1.echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
2. 配置 python36 的目录，加入环境变量
强调！！！
强调！！！
强调！！！
因为 path 的路径查找是有优先级顺序的！！！
并且在配置 virtualenv 的时候，优先以先找到的 python 环境为 base 环境
#请将 python36 的目录放到 path 的第一层
/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:
2. 配置环境变量，永久生效，写入到文件 /etc/profile 中，每次登录就生效
vim /etc/profile #将此配置写到最低行
PATH=/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin

3.source /etc/profile #读取这个文件，让 python3 生效
8. 此时可以正确使用 python3 啦！
9. 检查所有 python 的文件夹关系
[root@s14linux /opt 11:05:09]#ls
python36(这个是工作的，已经安全号的 python3 软件包目录)
Python-3.6.7(这个是 python3 的源码文件夹，安装成功后可删)
Python-3.6.7.tar 可删

10. 升级 pip 工具，升级 pip 的版本
pip3 install --upgrade pip

安装 ipython 解释器
1. 安装 ipython，指定 douban 源下载
pip3 install -i https://pypi.douban.com/simple ipython

2. 安装朱皮特
pip3 install -i https://pypi.douban.com/simple jupyter

3. 进入 ipython 环境，给 jupyter 设置密码
ipython #进入 ipython 的交互式界面

from IPython.lib import passwd

passwd()# 生成 jupyter 登录的密码

4. 生成 jupter 的的配置文件
jupyter notebook --generate-config --allow-root
5 编辑配置文件
vim ~/.jupyter/jupyter_notebook_config.py
修改如下配置一致即可，去掉注释符 # 才能读取代码
c.NotebookApp.ip = '建议写当前 linux 机器的 ip 地址'
c.NotebookApp.open_browser = False
c.NotebookApp.port = 8000

6. 启动朱皮特
notebook --allow-root #启动 notebook
ip:8000 端口访问你的 jupyter 页面

7. 如果启动不了，很可能是防火墙问题
iptables -L #查看规则
iptables -F #清空规则
systemctl stop firewalld #关闭防火墙服务
systemctl disable firewalld #从开机自启中，移除这个防火墙服务，永久关闭
#还有一个 selinux 得关闭
1. getenforce 查看 selinux 规则
2. 临时关闭 selinux setenforce 0
注意
永久关闭 selinux，需要重启生效
vim /etc/selinux/config
写入以下配置
SELINUX=disabled
#重启服务器生效,selinux 永久 disabled
#自由选择 python3 源码包的版本
https://www.python.org/ftp/python/
https://www.python.org/ftp/python/3.7.1/Python-3.7.1.tgz

#现在有个需求，我现在有两个项目，一个得运行于 django1.1.11 ，还有一个版本得跑在 django2.0 上
python3 manage.py runserver 0.0.0.0:8000 #我得调用 django 的模块， pip3 list ，运行了 django1.11.11

python3 manage.py runserver 0.0.0.0:9000 # 还得调用 django 的模块，我想运行 django2.0

#问题，能调用一个解释器吗？

1. 买俩电脑，装俩 python3
2. 装多个 python 解释器，在当前 linux 下，安装一个 python3.6 安装一个 python3.7
python3.6 manage.py runserver 0.0.0.0:8000 #我得调用 django 的模块， pip3 list ，运行了 django1.11.11

python3.7 manage.py runserver 0.0.0.0:9000 # 还得调用 django 的模块，我想运行 django2.0

3. 使用虚拟解释器环境，可以在一台服务器上，运行多个 python 解释器的环境
并且这个虚拟环境的创建，非常快速，简洁，好用
1. 新建虚拟环境 venv1
2. django2 运行在 venv2

#安装 django1.11.11
pip3 install -i https://pypi.douban.com/simple django==1.11.11

#linux 下的虚拟环境安装 (virtualenv)，以宿主机的 python 解释器为主体，然后复制的多个虚拟环境
1. 通过 pip3 安装虚拟环境
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv

2. 通过 virtualenv 命令，创建第一个新的虚拟环境
virtualenv --no-site-packages --python=python3 venv1

virtualenv --no-site-packages --python=python3 venv2

virtualenv --no-site-packages --python=python3 venv3

virtualenv --no-site-packages --python=python3 venv4

virtualenv --no-site-packages --python=python3 venv5
参数解释
--no-site-packages 创建一个干净，隔离宿主机环境的虚拟环境
--python=python3 #指定你的虚拟环境，以哪个解释器为 base 环境，我的这个是以我机器上的 python3 解释器为主体
3. 激活虚拟环境，切换宿主机环境，进入虚拟环境的环境变量
cd /opt/all_venv/venv1/bin/
source activate

4. 检查环境变量 PATH，检查是否正确激活了虚拟环境
(venv1) [root@s14linux ~ 12:03:48]#echo $PATH
/opt/all_env/venv1/bin:/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:

5. 检查你当前的 python3 和 pip3 来自于哪里
which python3
(venv1) [root@s14linux ~ 12:04:12]#which python3
/opt/all_env/venv1/bin/python3

which pip3

6. 使用 venv1 虚拟环境，安装一个 django1.11.11
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple django==1.11.11

7. 测试运行在一个服务器上，运行两个 django 版本
1. 宿主机 python 下运行 django2.0
2. 虚拟环境下运行 django1.11.11
8. 退出虚拟环境
deactivate
9.linux 下运行项目
创建项目
django-admin startproject mysite(项目名)
cd mysite
创建 app
django-admin startapp app01(app 名)
注册 app
vim mysite/settings.py
路由
vim mysite/urls.py
视图
vim app01/views.py
启动项目
python3 manage.py runserver 0.0.0.0:8000
下载 flask
pip3 install -i https://pypi.douban.com/simple flask
服务器环境之保证本地和服务器开发环境一致性的配置：
1. 通过命令导出当前 python 解释器的 pip3 包环境
pip3 freeze > requirements.py #这个 requirements.py 文件，就存放了正常运转的开发软件依赖包的信息
2. 将此 requirements.py 文件传到服务器上
在另一服务环境下执行 (将文件 requirements.py 中的包, 安装并使用)
pip3 install -r requirements.py
上传办法
1. yum install lrzsz
这个 lrzsz 软件提供了两个命令
1. sz (发送，下载) 从 linux 往 windows 下载
sz 你想传输的文件名字
2. rz(接收，上传) 从 windows 往 linux 上传
rz 直接输入 rz 命令
2. 通过 xftp(公司用 xftp)
虚拟环境管理之 virtualenvwrapper 安装使用步骤：
1. 下载安装 virtualenvwrapper
pip3 install -i https://pypi.douban.com/simple virtualenvwrapper

2. 执行脚本，让当前机器支持 virtualenvwrapper，但是有一个问题，重启后，退出会话后，这个功能就失效了

3. 配置全局变量，让每次登陆 linux 时候，就加载这个 virtualenvwrapper.sh 脚本文件，使得 virtualenvwrapper 这个工具生效

#打开这个用户环境变量配置文件，写入以下信息，export 就是读取一段 shell 变量的命令
vim ~/.bashrc #这个文件代表用户环境变量，每次登陆时候加载
export WORKON_HOME=~/Envs #设置 virtualenv 的统一管理目录
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages' #添加 virtualenvwrapper 的参数，生成干净隔绝的环境
export VIRTUALENVWRAPPER_PYTHON=/opt/python36/bin/python3.6 #指定 python 解释器，（这个得根据你自己机器环境来配）
source /opt/python36/bin/virtualenvwrapper.sh #执行 virtualenvwrapper 安装脚本，这个脚本放在你的 python3.6 解释器 bin 目录下
logout 重新登录
读取文件，使得生效，此时已经可以使用 virtalenvwrapper
source ~/.bashrc

4. 开始使用 virtualenvwrapper，创建一个 venv1
mkvirtualenv venv1 #这一步会创建 venv1，并且放入到 WORKON_HOME 变量定义目录下，并且自动激活虚拟环境

lsvirtualenv #查看当前机器所有的虚拟环境

workon venv1 #用于激活虚拟环境，也用于在多个虚拟环境中来回切换，

rmvirtualenv venv3 #用于删除虚拟环境，也会自动找到所有的虚拟环境

cdvirtualenv #用于直接进入虚拟环境的目录，此命令需要激活虚拟环境
(venv2) [root@cwlinux ~ 20:04:11]#cdvirtualenv
(venv2) [root@cwlinux ~/Envs/venv2 20:04:23]#

cdsitepackages #用于直接进入 pip3 软件包的目录
(venv2) [root@cwlinux ~/Envs/venv2 20:04:48]#cdsitepackages
(venv2) [root@cwlinux ~/Envs/venv2/lib/python3.6/site-packages 20:05:43]#

5. 友情提醒
使用了 virtualenvwrapper 就不需要再手动安装 virtualenv 了，
day107Linux 笔记

mariadb 其实就是 mysql
mysql 已经被 oracle 收购，它即将闭源，马上要开始收费了
因此还想免费试用开源的数据库 mysql，就在 centos7 上，将 mysql 分支为 mariadb

安装 mariadb，在 centos7 底下:
linux 软件包的格式 mysql.rpm

1. 通过 yum 去安装
1.linux 的 yum 软件管理目录在 /etc/yum.repos.d
2. 在这个目录底下，主要是 *.repo 这个文件，就会被识别为 yum 源文件
第一种方式是，通过阿里云的 yum 源去下载 (第三方的 yum 源，可能会版本较低，且软件不全，可能找不到)
CentOS-Base.repo epel.repo

yum install mariadb-server #yum 安装 mariadb 因为这个阿里云特别快，咱们用他去学习，加速下载 300kb/s
mariadb-server x86_64 1:5.5.60-1.el7_5 base 11 M
为依赖而安装:
mariadb x86_64 1:5.5.60-1.el7_5 base 8.9 M
perl-DBD-MySQL x86_64 4.023-6.el7 base 140 k
为依赖而更新:
mariadb-libs x86_64 1:5.5.60-1.el7_5 base 758 k

第二种方式是，通过 mariadb 官方的 yum 源去下载 (一定是这个软件最正确的 yum 源，且包都是最新的)
1. 下载一个第三方的软件，顺序就是去官网找到这个软件的下载方式
yum install MariaDB-server MariaDB-client #区分大小写 ，这个方式是取国外下载 mariadb，速度太慢 30kb/s
依赖关系解决
=====================================================================================================================================
Package 架构 版本 源 大小
=====================================================================================================================================
正在安装:
MariaDB-client x86_64 10.1.37-1.el7.centos mariadb 40 M
MariaDB-server x86_64 10.1.37-1.el7.centos mariadb 104 M
MariaDB-shared x86_64 10.1.37-1.el7.centos mariadb 1.3 M
替换 mariadb-libs.x86_64 1:5.5.56-2.el7
为依赖而安装:
MariaDB-common x86_64 10.1.37-1.el7.centos mariadb 123 k
boost-program-options x86_64 1.53.0-27.el7 base 156 k
galera x86_64 25.3.24-1.rhel7.el7.centos mariadb 8.1 M

1. 下载 mariadb，通过阿里云的源
cd /etc/yum.repos.d
yum install mariadb-server
2. 通过 yum 安装的软件，systemctl start/stop/restart/status mariadb
systemctl start mariadb #启动 mariadb 数据库
3. 初始化 mariadb
mysql_secure_installation #直接输入这个命令，设置 root 密码，删除匿名用户等等操作
4 登录
mysql -uroot -p
5. 配置 myariadb 远程登录，可以通过 windows，pycharm 等客户端进行连接，在远端登录的话，就必须得输入 redhat 这个密码
grant all privileges on *.* to root@'%' identified by 'redhat';
授予 所有的 权限 在 所有的库. 所有的表 用户名 @"所有的地址" identified by "密码";

6. 刷新授权表，使得权限立即生效
flush privileges;

7. 更改 mysql 的密码
set password = PASSWORD('redhat123');

8. 创建普通用户 s14
create user s14@'%' identified by 's14666';
create user 用户名 @'%' identified by '密码';
9. 查询用户信息
select host,user,password from user;

10. 授权语句
grant 权限 on 数据库. 表名 to 账户 @主机名 对特定数据库中的特定表授权
grant 权限 on 数据库.* to 账户 @主机名 　　对特定数据库中的所有表给与授权
grant 权限 1, 权限 2, 权限 3 on *.* to 账户 @主机名 　　 对所有库中的所有表给与多个授权
grant all privileges on *.* to 账户 @主机名 　　 对所有库和所有表授权所有权限
grant create,select,insert on *.* to root@'%' identified by "密码"

10. 数据库的中文设置
1. 查看数据库编码
\s
2. 修改 mysql 的配置文件 /etc/my.cnf ，加入以下信息
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
log-error=/var/log/mysqld.log
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
\
3. 修改了配置文件，重启服务
systemctl restart mariadb

4. 查看数据库创建的编码，只有在更新了数据库编码之后，创建的数据库，才会使用这个编码
show create database s14;
5. 可以测试创建 table，写入中文数据
use s14;
create table s14(id int,name char(32));
insert into s14(id,name) values(1,"哈哈");
select *from s14
11.mysql 的数据备份
1. 通过命令导出全部数据
mysqldump -u root -p --all-databases > /data/db.dump
2.mysql 的数据文件都放在 /var/lib/mysql/* 中，所有的 db 信息，以及账号密码信息
rm -rf /var/lib/mysql/* #清空 mariadb 所有数据
3. 导入数据库的 db 文件，在 mysql 命令行中输入这个命令
source /data/db.dump
4. 第二种方式导入数据，通过 mysql 命令
mysql -uroot -p < /opt/db.dump

mysql 主从复制的步骤：

环境准备：
准备两台服务器，安装两个 mariadb

主库是：192.168.12.96 mater
从库是：192.168.12.87 slave

主库的操作如下：
1. 开启 binlog 功能，修改 /etc/my.cnf
vim /etc/my.cnf #写入
[mysqld]
server-id=1 #指明主库的身份 id 为 1
log-bin=mysqls14-bin #指明 binlog 的日志名

2. 修改了配置文件，重启 mariadb，使得 binlog 生效
systemctl restart mariadb

3. 登录 mysql，检查主库的状态
show master status;

4. 创建一个用户，用于进行主从同步
create user 'abc'@'%' identified by 'chenwei';

5. 授予账号权限，授予一个从库的身份权限
grant replication slave on *.* to 'abc'@'%';

6. 锁定 mysql 的表，防止数据写入
flush table with read lock;

7. 主从同步，将从库与主库的数据，保持一致后，它俩都在同一个起跑线，然后解除锁表，一同写入数据，保证数据一致性
1. 导出当前的数据，用于 slave 机器导入数据，保证在一个起始点
mysqldump -u root -p --all-databases > /data/db.dump
2. 将此 db.dump 文件远程传输给 slave 机器，用于导入
scp /data/db.dump root@192.168.12.89:/tmp/
3. 登录 slave 从库，导入主库的数据信息
mysql > source /tmp/db.dump
4. 查看主库和从库的信息，是否一致

8. 查看主库的状态信息,binlog 信息
show master status;

9. 解锁表，开始主从同步
unlock tables;

从库的设置：
1. 在 /etc/my.cnf 当中打开 server-id
vim /etc/my.cnf
server-id=10

2. 重启 myariadb
systemctl restart mariadb
3. 查看 slave 机器的身份信息
show variables like 'server_id';
show variables like 'log_bin';

4. 通过命令，开启主从同步技术
change master to master_host='192.168.12.120',
master_user='abc',
master_password='chenwei',
master_log_file='mysqls14-bin.000003',
master_log_pos=467;

5. 开启 slave
start slave;

6. 检查 slave 状态，检查两条参数，如果都是 yes，即主从 ok
show slave status\G;
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
7. 此时可以在主库中写入数据，查看从库中是否生成了记录
主库：插入数据 create detabase aaaa;

从库：检查数据 show databases;

Mariadb 的 sql:
增
create database s14;
create table s14tb(id int,name char);
insert into s14tb (id ,name) values(1,"s14")

删
drop database s14;
drop table s14tb; #删除整张表
delete from s14tb;

改
update

查
select id,name,addr from table;

redis 相关配置
1.yum 源码 rpm
yum 快速，间接，高效，解决依赖关系，（自动安装到某个路径，不可控），通过 yum 安装的软件查询命令
rpm -ql nginx
yum 源的软件包可能版本非常低
源码安装，可扩展第三方的功能 (可以指定目录安装, configure --prefix=/opt/python36/)
可以通过官网的最新代码，进行编译安装

通过源码安装
1. 在线下载 redis 源码包
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
2. 解压缩 redis 源码包，如果源码包带有.gz 结尾，需要通过 gzip 指令扩展，也就是 -z 的参数
tar -zxvf redis-4.0.10.tar.gz #v 解压缩这个文件，且显示解压缩过程
3. 切换目录到 redis 源码包
cd redis-4.0.10
4. 由于 redis 没有 configure 脚本，直接就有了 makefile，因此可以直接编译且安装
make #编译
make install #安装
#此两条命令可以缩写为一条， make && make install
5. 编译安装完成后，redis 默认会将 redis 命令添加到环境变量中 /usr/local/bin 底下
6. 启动 redis 服务端，自定义一个 redis.conf
重命名
mv redis.conf redis.conf.bak
删除注释行和空白行, 重定位
grep -v '^#' redis.conf.bak | grep -v '^$' > redis.conf
vim redis.conf ，写入以下内容 (不要加上注释)
dG 删除所有行
port 6379
daemonize no #后台运行 redis
pidfile /data/6379/redis.pid #将 redis 进程的 id 写入到 redis.pid 这个文件
loglevel notice #日志级别
logfile "/data/6379/redis.log"
dir /data/6379 #配置 redis 数据存放点
protected-mode yes #redis3.0 之后的安全模式
建立文件夹
mkdir -p /data/6379
启动 redis 服务
redis-server redis.conf
连接
redis-cli
测试
ping 返回连接成功结果 PONG
启动 redis 服务页面行住了, 所以:
port 6379
bind 0.0.0.0
daemonize yes #后台运行 redis
pidfile /data/6379/redis.pid #将 redis 进程的 id 写入到 redis.pid 这个文件
loglevel notice #日志级别
logfile "/data/6379/redis.log"
dir /data/6379 #配置 redis 数据存放点
protected-mode yes #redis3.0 之后的安全模式

启动 redis 服务
redis-server redis.conf
连接
redis-cli
测试
ping 返回连接成功结果 PONG
set name s14
keys *
redis 的安全模式，可能会阻挡你远程连接，为了解决这个安全模式，给 redis 设置一个密码
port 6379
bind 0.0.0.0
daemonize yes #后台运行 redis
pidfile /data/6379/redis.pid #将 redis 进程的 id 写入到 redis.pid 这个文件
loglevel notice #日志级别
logfile "/data/6379/redis.log"
dir /data/6379 #配置 redis 数据存放点
protected-mode yes #redis3.0 之后的安全模式
requirepass qiangdademima #给 redis 设置一个密码
停掉 redis 服务进程
redis-cli shutdown
启动服务
redis-server redis.conf
连接
redis-cli
连接后需要认证登录密码才可以
AUTH qiangdademima
测试
ping 返回连接成功结果 PONG
set name s14
keys *
7.redis 的多实例功能，可以在一个机器上，启动多个 redis 服务端
1. 准备一个新的配置文件，redis 默认支持多实例，再准备一个新的配置文件 redis-6380.conf，
cp redis.conf redis-6380.conf
vim redis-6380.conf
port 6380
bind 0.0.0.0
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dir /data/6380
protected-mode yes
requirepass henqiangdademima
2. 建立文件夹
mkdir -p /data/6380
3. 启动第二个 redis 实例（第二个数据库）
redis-server redis-6380.conf
4. 连接
redis-cli -p 6380
5. 认证
AUTH zenqiangdademima
6. 测试
ping
7. 通过命令查询 redis 的密码参数
CONFIG get requirepass

redis 发布订阅
1. 一个发布者，多个订阅者
-a 参数意思是指定 redis 的密码登录
redis-cli -a qiangdademima #启动 1 个 redis 客户端 (订阅者 1)
SUBSCRIBE 频道名字
SUBSCRIBE s14diantai

redis-cli -a qiangdademima #启动 2 个 redis 客户端 (订阅者 2)
SUBSCRIBE 频道名字
SUBSCRIBE s14diantai
redis-cli -a qiangdademima #启动 3 个 redis 客户端 (发布者)
PUBLISH 频道名字 想发送的消息
PUBLISH s14diantai hahahaah
2. 支持正则的匹配订阅者
-a 参数意思是指定 redis 的密码登录
redis-cli -a qiangdademima #启动 1 个 redis 客户端 (订阅者 1)
PSUBSCRIBE 频道名 *
PSUBSCRIBE s1*
redis-cli -a qiangdademima #启动 2 个 redis 客户端 (订阅者 2)
PSUBSCRIBE 频道名 *
PSUBSCRIBE s1*
redis-cli -a qiangdademima #启动 3 个 redis 客户端 (发布者)
PUBLISH 频道名字 * 发送的消息
PUBLISH s14 miaomiaomiao
redis 持久化之 rdb 与 aof
rdb 模式
1. 在配置文件中写入参数，支持 rdb 模式
vim redis.conf
port 6379
bind 0.0.0.0
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dir /data/6379
protected-mode yes
requirepass qiangdademima
2. 连接服务端
redis-cli -a qiangdademima
创建数据
set name chenwei
set age 122
查看数据
keys *
退出
exit
3. 删除数据库实例
查看进程
ps -ef|grep redis
杀死 redis-server
killall redis-server
pkill redis-server
4. 启动 redis 服务端
redis-server redis.conf
5. 连接服务端
redis-cli -a qiangdademima
查看数据
keys *
结果: 数据为空
redis 运用于购物车的清空服务, 服务挂掉数据清空
所以: 加 redis 持久化
6.vim redis.conf
port 6379
bind 0.0.0.0
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dir /data/6379
protected-mode yes
requirepass qiangdademima
dbfilename dbmp.rdb
save 900 1
save 300 10
save 60 10000
7. 启动 redis 服务端，此时可以设置 redis 的 key，通过 save 命令触发 rdb 持久化
1.redis-server redis.conf
2.cd /data/6379
3.ls #此时是没有 dump.rdb
4. 连接服务端
redis-cli -a qiangdademima
查看数据
keys * #此时数据为空
创建数据:
set name chenwei
set age 122
手动触发
save
5.ls /data/6379 #生成 dump.rdb
aof 模式
1.vim redis.conf #写入以下
port 6379
bind 0.0.0.0
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dir /data/6379
protected-mode yes
requirepass qiangdademima
dbfilename dbmp.rdb
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec
2. 查看进程
ps -ef|grep redis
3. 杀死 redis-server 进程
pkill redis-server
4. 启动 redis 服务端
redis-server redis.conf
5.
cd /data/6379
ls
生成 appendonly.aof 和 redis.pid
此时进入 redis-cli 的操作，都会被记录，且追加到 appendonly.aof 文件中，以达到持久化的操作
6. 实时监控追加数据
tail -f appendonly.aof
7. 连接服务器端
redis-cli -a qiangdademima
8. 创建数据:
set name chenwei
set age 122
redis 持久化方式有哪些？有什么区别？
rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于 rdb 持久化功能

aof：以追加的方式记录 redis 操作日志的文件。可以最大程度的保证 redis 数据安全，类似于 mysql 的 binlog
day108Linux 笔记

web 服务器软件
IIS (windows 底下的 web 服务器软件)

Nginx (Linux 底下新一代高性能的 web 服务器)
Tengine www.taobao.com 这是淘宝

Apache (Linnux 上个时代的，老企业会选择 apache)
http://www.gov.cn/

Linux 发起网络请求命令 curl

公司的网站技术架构

LAMP 的一个技术栈
linux apache mysql php #搭建一个黄金组合，lamp

闭源技术架构
redhat + apache + oracle + java + nagios(监控服务器软件) + SVN(代码托管平台)
走向开源
centos + nginx + mysql + python + saltstack(运维软件，可以在一台机器上，管理多个机器)+ zabbix(监控软件) + git()

不同的 python 框架支持的 QPS 吞吐量是多少呢？ 通过 ab 这个命令，压测软件来测试一个不同 (启动 10 个并发请求，发起 10000 个连接)，运行 django，运行 flask、运行 tornado
flask 600 req/s
django 1000..
tornado(异步非阻塞) 2000...
sanic (python3.7 之后的一个异步框架。uvloop 出) ，3000...

golang
net/http 6W (很多互联网公司，知乎 (py2 > golang)，滴滴都在 python > golang )

编译安装 nginx：
1. 解决依赖关系
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. 下载源码包
wget -c https://nginx.org/download/nginx-1.12.0.tar.gz
3. 解压缩源码包
tar -zxvf nginx-1.12.0.tar.gz
4. 在当前路径下通过 configure 这个脚本文件执行，释放 makefile，然后指定安装 nginx 的路径，以及开启模块功能 ssl 与状态模块功能
./configure --prefix=/opt/nginx1-12/ --with-http_ssl_module --with-http_stub_status_module
nginx path prefix: "/opt/nginx1-12/" # nginx 的安装路径
nginx binary file: "/opt/nginx1-12//sbin/nginx" # nginx 的启动脚本存放路径
nginx configuration prefix: "/opt/nginx1-12//conf" # nginx 的配置文件路径
nginx http proxy temporary files: "proxy_temp" # nginx 的代理功能参数
nginx http fastcgi temporary files: "fastcgi_temp" # 与 php 结合的功能参数
nginx http uwsgi temporary files: "uwsgi_temp" # 与 uwsgi 服务器结合的参数
5. 编译且编译安装
make && make install
6. 在 /opt/nginx1-12/ 安装好 nginx 的目录，找到一个 sbin 的文件夹，找到 nginx 的启动命令，然后启动 nginx 服务
1. 检查 nginx 安装后的目录，ll /opt/nginx1-12
drwxr-xr-x 2 root root 333 12 月 6 09:32 conf 配置文件存放的目录, nginx.conf 这个文件就是 nginx 的主配置文件
drwxr-xr-x 2 root root 40 12 月 6 09:32 html 存放网页根目录的文件夹，存放了 index.html **.html **.gif **.jpg
drwxr-xr-x 2 root root 6 12 月 6 09:32 logs 日志目录
drwxr-xr-x 2 root root 19 12 月 6 09:32 sbin nginx 启动脚本目录
2.nginx 的可执行命令
- rwx(user) r-x(group) r-x(other) 1 root(属主) root(属组) 5656000 12 月 6 09:32 sbin/nginx
7 5 5
3. 启动 nginx 服务
./sbin/nginx #直接启动 nginx
./sbin/nginx -s stop
./sbin/nginx -s reload #平滑重启 (修改了 nginx 配置文件，不重启服务就加载配置且生效)
../sbin/nginx -t 检测 nginx.conf 配置文件的语法正确性
7. 检查端口，进程，然后通过浏览器访问 nginx 页面，192.168.12.96:80
1. 端口连接数
netstat -tunlp|grep 80
2. 进程
ps -ef|grep nginx
3. 查看目录下文件
ls
client_body_temp conf fastcgi_temp html logs proxy_temp sbin scgi_temp uwsgi_temp
4. 浏览器访问 192.168.12.120:80
展示 html-->index.html 的页面
5. 修改页面
cd html/
vim index.html
6. 查看前端页面内容
curl 192.168.12.120
curl -I 192.168.12.120

8.nginx 的主配置文件，nginx.conf 修改
1.cd /opt/nginx1-12/conf
2.vim nginx.conf
#虚拟主机 1
server {
listen 81;
server_name localhost; #这里是 nginx 通过这个参数，来定位不同的虚拟主机
#charset koi8-r;
#access_log logs/host.access.log main;
#代表访问 nginx 的匹配路劲
location / {
#指明网页根目录在 /opt/html 文件下
root /opt/html;
#相对路径
index index.html index.htm;
}
}
3. 平滑重启 nginx
../sbin/nginx -s reload
4. 检测 nginx.conf 配置文件的语法正确性
../sbin/nginx -t
5. 创建 index.html 页面
cd /opt
mkdir html
cd html
touch index.html
vim index.html 写入
<meta charset=utf8>
<h1> 啊哈哈哈哈哈哈, 你来打我呀 </h1>
6. 浏览器访问 192.168.12.120:81
展示 /opt/html-->index.html 的页面
7. 下载一张图片放到 /opt/html 下, 图片名:1.jpg
浏览器访问 192.168.12.120:81/1.jpg

#一台服务器，安装了一个 web 服务软件

#假设我超弟想创业，准备 2 个网站，展示不同的片

#资源浪费，一个服务器至少也是 50G 的磁盘，浪费钱

一个服务器，安装一个 web 软件，展示一个页面

再主板一个服务器，再安装一个 web 软件，展示一个页面

卖片，火影忍者 www.chenwei.com 展示不同的网站资料，mp4，图片，动态图，html 静态资源，超链接
卖片，韩剧 TV www.gaoge.com 展示不同的网站资料，mp4，图片，动态图，html 静态资源，超链接

nginx 多虚拟主机，在一台机器上，安装一个 nginx，运行多个虚拟主机, 不同的虚拟主机，返回不同的页面

#多虚拟主机的配置
1.cd /opt/nginx1-12/conf
2.vim nginx.conf
3. 修改 nginx 底下的 conf/nginx.conf ，修改信息如下
#虚拟主机 1
server {
listen 80;
server_name www.chenwei.com;
#代表访问 nginx 的匹配路劲
location / {
#指明网页根目录在 /data/chenwei 文件下
root /data/chenwei;
#相对路径
index index.html index.htm;
}
}
#虚拟主机 2
server {
listen 80;
server_name www.gaoge.com;
#代表访问 nginx 的匹配路劲
location / {
#指明网页根目录在 /data/gaoge 文件下
root /data/gaoge;
#相对路径
index index.html index.htm;
}
}

4. 重新加载 nginx 配置文件
../sbin/nginx -t #检测语法
../sbin/nginx -s reload #平滑重启

5. 准备不同的虚拟主机的站点资料
放入不同的资料如下
├── chenwei
│   ├── 1.jpg
│   └── index.html
└── gaoge
├── index.html
└── 2.jpg
mkdir -p /data/{chenwei,gaoge}
cd /data/chenwei
6. 创建 index
touch index.html
vim index.html
<meta charset=utf8>
<h1> 我是高哥, 我喜欢新垣结衣 </h1>
<img src='2.jpg'>
7. 写入到本地 dns 解析文件，由于我是在 windows 中通过浏览器访问，应该在 windows 的 hosts 文件中添加记录
hosts 文件就是一个本地 dns(就是将域名转化成 ip 地址) 强制解析的文件

windows 的 hosts 文件就在这里：C:\Windows\System32\drivers\etc\hosts ，写入如下信息
192.168.12.120 www.chenwei.com
192.168.12.120 www.gaoge.com

8. 在 windows 中，测试访问多域名配置
www.chenwei.com
www.gaoge.com

nginx 状态模块功能：
vim /opt/nginx1-12/conf/nginx.conf
1. 在配置文件中，添加一个参数即可
location /status {
stub_status on;
}

nginx 访问日志功能：
1. 在配置文件中，打开注释，nginx.conf
vim /opt/nginx1-12/conf/nginx.conf
log_format main '$remote_addr - $remote_user [$time_local]"$request" '
'$status $body_bytes_sent"$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log logs/access.log main;
参数详解：
$remote_addr 记录客户端 ip
$remote_user 远程用户，没有就是 “-”
$time_local 　　 对应 [14/Aug/2018:18:46:52 +0800]
$request　　　 　对应请求信息 "GET /favicon.ico HTTP/1.1"
$status　　　 　状态码
$body_bytes_sent　　571 字节 请求体的大小
$http_referer　　对应“-”　　由于是直接输入浏览器就是 -
$http_user_agent　　客户端身份信息
$http_x_forwarded_for　　记录客户端的来源真实 ip 97.64.34.118

打开了功能之后，可一通过 access_log 查看用户身份信息
192.168.12.60 - - [06/Dec/2018:11:24:04 +0800] "GET / HTTP/1.1" 304 0 "-" "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36" "-"

nginx 的错误页面优化：
1. 在配置文件中添加 nginx.conf
vim /opt/nginx1-12/conf/nginx.conf
server {
listen 80;
server_name www.chenwei.com;
location / {
#指明网页根目录在 /opt/html/ 文件夹下
root /data/chenwei;
index index.html index.htm;
deny 192.168.12.120;
}
error_page 401 402 403 404 /40x.html;
#当请求来自于 wwww.chenwei.com/status/
}
ab -kc 1000 -n 10000000 http://192.168.12.87/

day109Linux 笔记
web 知识博客：https://www.cnblogs.com/pyyu/p/9467256.html
nginx 博客：https://www.cnblogs.com/pyyu/p/9468680.html
nginx 负载均衡博客：https://www.cnblogs.com/pyyu/p/10004633.html

昨日内容回顾：
nginx 安装配置
nginx 目录下的 sbin 文件夹 nginx 绿色的执行文件
nginx 底下的 conf 文件夹 nginx.conf 是主配置文件
nginx.conf 通过闭合的大括号，来确定代码作用域
server{} 标签定义虚拟主机
server{
listen 80;
server_name 域名或者 ip 地址; www.s14.com
#网站访问的路径匹配
# www.s14.com/s14.png
# www.s14.com/index.html
location / {
#root 参数定义，这个虚拟主机访问入口时，定位的资源文件放在哪
#用于定义虚拟主机，网站根目录
root /data/static/; #如果我在这放了一个图片 /data/static/s14.png
index index.html #定义默认的首页文件名叫做 /data/static/index.html
}

} 多个标签，定义多个虚拟主机

#错误页面的定义 这个 /40x.html，代表必须在 root 定义的网页根目录下，存在 /data/static/40x.html，如果没有文件则 touch 40x.html
# www.s14.com/weqwewqe12312312312
errror_page 状态码 400 401 404 /40x.html

#访问日志，打开配置文件的注释即可

 

#web 服务基础知识
c/s 客户端 / 服务器
b/s 浏览器 / 服务器

nginx > web server 服务端
浏览器 > web client 客户端

#dns 解析流程
1. 首先用户输入一段 url，在浏览器 www.oldboyedu.com
2.(dns 解析的第一步) 浏览器会首先在你的机器上，寻找一个 hosts 文件, 这是本地测试 dns 解析文件
2.（第二步）如果 hosts 文件未指定解析记录，浏览器就去机器的 dns 缓存中寻找解析记录 LDNS（local dns 缓存）
3.（第三步）如果缓存也没有记录，去指定的 dns 服务器中 (手动配置，linux 底下 /etc/reslove.)，去网络中寻找解析记录
/etc/resolv.conf
写入两条 dns 记录
主 dns 服务器 nameserver x.x.x.x
备 dns 服务器 nameserver x.x.x.x

linux 解析 dns 的命令
nslookup(nameserver lookup 域名服务器查找)
nslookup www.baidu.com
4.dns 服务器会将查找到的 ip 和域名对应的记录，返回给浏览器，浏览器就知道访问的 ip 服务器是谁了
5. 此时操作系统会将这条解析记录，写入到本地 dns 缓存中，LDNS

#状态码
300 系列就是 你访问的 url 经过重定向 redirect， baidu.com > diaoyu.baidu.com
例如: 访问 mirrors.aliyun.com,, 重定向跳转到 https://opsx.alibaba.com/mirror

location: 指令的作用是根据用户请求的 url 来执行不同的应用
1. vim /opt/nginx1-12/conf/nginx.conf
2. 写入
#www.gaoge.com/s14/s14.txt
location /s14 {
alias /data/s14/;
}
3. 创建 /data/s14 文件夹
4.touch s14.txt
5. 写入数据
6. 访问浏览器 www.gaoge.com/s14/s14.txt
nginx location 语法：
location 支持的语法优先级：
1.location = / {
我是代码 1
} 精确匹配
2.location ^~ /images/ {
我是代码 2
} 匹配常规串，不做正则检查
3.location ~* \.(gif|jpg|jpeg) {
我是代码 3
} 正则匹配
4. location /av/ {
我是代码 4
} 匹配常规字符，有正则优先正则
#如果你谁都没匹配到的话，默认走 /，走网页根目录，优先级最低
5.location / {
我是代码 5
} 所有的 location 都不匹配后，默认匹配
location 匹配顺序
1. vim /opt/nginx1-12/conf/nginx.conf
写入:
server {
listen 80;
server_name www.aaa.com;
#代表访问 nginx 的匹配路劲
location / {
return 401;
}
location =/ {
return 402;
}
location /documents/ {
return 403;
}
location ^~ /images/ {
return 404;
}
location ~* \.(gif|jpg|jpeg)$ {
return 500;
}
}
2. 平滑重启 nginx
./sbin/nginx -s reload
3. 浏览器访问 (优先级:1-->402,2-->404,3-->500,4-->403,5-->401)
www.aaa.com -->402
www.aaa.com/documents -->401
www.aaa.com/documents/ -->403
www.aaa.com/documents/1.jpg -->500
www.aaa.com/documents/asf -->403

www.aaa.com/hello
www.aaa.com/reg
www.aaa.com/login
#我的请求发给 nginx 的时候，nginx 不做处理，直接返回给 django
location / {
uwsgi_pass http:0.0.0.0:8000;
}

#如果你想请求图片资源，就直接丢给 nginx 去做处理
#nginx 处理静态资源更为优秀

#动静分离的效果，动态请求直接 location 匹配，转发给 django
#静态资源请求，解析到转发给 nginx 直接处理

正向代理
代理的是客户端
通过 vpn 的身份去请求国外的资源 (服务器其你去 --> 代理服务器端 --> 国外服务器)
反向代理
代理的是服务端
服务器请求 -->nginx 代理 django 服务器 --> 国外服务器
直接请求 django 的话, 由于 django 默认用的是 wsgigiref 单机模块, 性能很低
, 因此用户不会直接请求 django. 通过 uwsgi 一个软件 (高并发) 启动多进程处理用户请求,
uwsgi 不解析 django 的静态文件, 因此, 得通过 ngins 处理 django 项目的静态文件

nginx 的反向代理功能就是 proxy_pass 参数
1. 配置方式，准备 2 台机器
2. 查看进程
ps -ef|grep nginx
3. 杀死两台机器的 nginx 进程
pkill nginx
4. 在机器 1 中，添加参数
vim /opt/nginx1-12/conf/nginx.conf
写入:
server {
listen 80;
server_name www.bbb.com;
location / {
proxy_pass http://192.168.12.89; #请求会直接转发给 node2 节点，也就是 http://192.168.12.89;
}
}
5. 启动 nginx
/opt/nginx1-12/sbin/nginx
opt/nginx1-12/sbin/nginx -s reload
6. 启动机器 2 的 nginx
/opt/nginx1-12/sbin/nginx
7. 在两台机器上，检测 access.log ，查看请求来源
tail -f /opt/nginx1-12/logs/access.log
8. 浏览器访问 www.bbb.com
返回 192.168.12.89 的 html 页面

 

710144 GB = 710TB

1024KB 1MB

1024MB 1GB

1024GB 1TB
xshell 的快捷用法：
找到查看 > 撰写 > 撰写栏

nginx 负载均衡配置
1. 环境准备，准备 3 台服务器
192.168.12.96 nginx 入口 node1
192.168.12.67 康琛的应用服务器
192.168.12.38 伟华的应用服务器

2. 关闭所有机器的防火墙
查看防火墙
iptables -L
getenforce
关闭防火墙
iptables -F
setenforce 0

3. 在 node1 节点上配置负载均衡配置（发牌人）
1. 修改配置文件 nginx.conf ，写入如下配置
vim /opt/naginx1-12/conf/nagios.conf
upstream s14django {
#池子中存放 2 个服务器，默认轮训方式调度服务器
server 192.168.12.38:8000;
server 192.168.12.67:8000;
}
#虚拟主机 1
server {
listen 80;
server_name www.s14chenwei.com;
location / {
#当请求发送到 www.s14chenwei.com 的时候，匹配到 / ，就执行以下代码
proxy_pass http://s14django;
#包含语法参数，将一个配置文件添加到当前虚拟主机生效，这个文件要手动创建
#这个 proxy_params 文件创建在 /opt/nginx1-12/conf 底下
include proxy_params;
}
}

#root 参数定义网页的根目录，可以写在虚拟主机内，局部变量
#如果写在 server 标签外，就是全局变量
2. 手动创建这个参数文件
touch /opt/nginx1-12/conf/proxy_params
写入信息
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_connect_timeout 30;
proxy_send_timeout 60;
proxy_read_timeout 60;

proxy_buffering on;
proxy_buffer_size 32k;
proxy_buffers 4 128k;

4. 配置 weihua 的应用服务器
1. 准备一个 flask 代码，运行
pip3 install flask
2. 准备代码 myflask.py
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
return "<h1> 我是伟华 </h1>"
if __name__=="__main__":
app.run(host='0.0.0.0',port=8000)
3. 启动应用服务器
python3 myflask.py

5. 配置 chenchen 的应用服务器
1. 准备一个 flask 代码，运行
pip3 install flask
2. 准备代码 myflask.py
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
return "<h1> 我是琛琛 </h1>"
if __name__=="__main__":
app.run(host='0.0.0.0',port=8000)
3. 启动应用服务器
python3 myflask.py
6. 浏览器访问 (访问自己的 nginx 负载均衡的 ip 地址，查看结果)
www.s14chenwei.com
通过访问 nginx 负载均衡器入口，查看负载均衡 是否正常分配，默认是轮训方式
7 权重
server 192.168.12.38:8000 weight=3;
server 192.168.12.67:8000 weight=7;
8.ip_hash 与 weight 不能同时用
ip_hash:
server 192.168.12.38:8000;
server 192.168.12.67:8000;
redis 持久化
RDB
基于快照的持久化
通过 save 命令，强制持久化
在 redis.conf 中
dbfilename dbmp.rdb
save 900 1
save 300 10
save 60 10000

AOF
将修改命令，全部收集写入到一个 aof 文件中
appendonly yes
appendfsync everysec #每秒钟记录一次变化

RDB 数据切换 AOF 数据的操作
1. 查看 redis-server 进程, 并杀死进程
ps -ef|grep redis-server
pkill redis
2. 准备 redis.conf 配置文件，确保开启 rdb 功能, 配置参数如下
vim /opt/redis-4.0.10/redis.conf
port 6379
daemonize yes
pidfile /data/redis.pid
loglevel notice
logfile "/data/redis.log"
dir /data/
dbfilename dbmp.rdb
save 900 1
save 300 10
save 60 10000
3. 启动 redis 服务端
redis-server redis.conf
4. 插入 redis 数据，通过 save 命令，强制写入持久化 rdb 文件 (此时还是使用 rdb 持久化)
redis-cli
set name shahe
set age 11
save
5. 通过命令，切换到 aof 持久化，（注意此步只是临时生效，必须将 AOF 的配置，写入 redis.conf）
127.0.0.1:6379> CONFIG set appendonly yes #开启 AOF 功能
OK
127.0.0.1:6379> CONFIG SET save "" #关闭 RDB 功能
OK

6. 修改配置文件，添加 aof 参数，(此步重启后，rdb 持久化完全切换 aof 持久化，且数据保持一致)
vim /opt/redis-4.0.10/redis.conf
port 6379
daemonize yes
pidfile /data/redis.pid
loglevel notice
logfile "/data/redis.log"
dir /data/
appendonly yes
appendfsync everysec

6. 重启 redis 服务
redis-server redis.conf
redis-cli
keys *

redis 主从复制：
1. 环境准备 3 个 redis 实例
6380.conf
6381.conf
6382.conf
2.vim /opt/redis-4.0.10/6380.conf
vim /opt/redis-4.0.10/6381.conf
vim /opt/redis-4.0.10/6382.conf
三个配置文件的区别，仅仅是端口的不同修改即可
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no
3. 启动三个 redis 实例
redis-server 6380.conf
redis-server 6381.conf
redis-server 6382.conf

4. 此时可以查看 redis 身份信息，通过 info 参数 () 此时还未配置主从，因此都是 master 身份
redis-cli -p 6382 info Replication
redis-cli -p 6381 info Replication
redis-cli -p 6380 info Replication

5. 配置从节点的身份 (6380 为主，6381,6382 为从)，通过命令指明 master 节点信息即可
redis-cli -p 6381
127.0.0.1:6381> SLAVEOF 127.0.0.1 6380
redis-cli -p 6382
127.0.0.1:6382> SLAVEOF 127.0.0.1 6380

6. 查看各个各个节点的身份信息
redis-cli -p 6382 info Replication 从节点
redis-cli -p 6381 info Replication 从节点
redis-cli -p 6380 info Replication () 主节点

#手动切换主从身份
1. 将主节点挂掉
kill -9 主节点 6380

2. 将 6382 去掉 slave 的身份
redis-cli -p 6382 slaveof no one

3. 将 6381 设置新的主人，设置为 6382
redis-cli -p 6381 slaveof 127.0.0.1 6382

#通过配置文件，决定主从身份
1. 在配置文件中，添加一条参数即可 (主节点不做配置，从节点指明主人的 ip 端口信息即可)
slaveof 将 ip 作为主身份
vim /opt/redis-4.0.10/6380.conf
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no
slaveof 127.0.0.1 6381
今日内容：
博客地址：
https://www.cnblogs.com/pyyu/p/9481344.html

linux 基本管理命令

服务器上安装服务,python3.6(宿主机上的物理解释器)
1. 虚拟解释器
virtualenv
虚拟出多个干净、隔离的 python 解释器环境
问题：管理上较为麻烦，需要找到 venv 的路径，并且 source activate 才能激活虚拟环境
2.
virtualenvwrapper 工具
更为方便的使用以及管理 virtualenv
1. 配置好环境变量之后，每次开机就加载这个软件
2.workon 激活并且切换多个虚拟环境
mkvirtualenv 创建
lsvirtualenv
cdvirtualenv
rmvirtualenv

mariadb(mysql)，与 django 连接，存储数据 (yum install mariadb-server mariadb-client)
初始化连接数据库
__init.py__
import pymysql
pymysql.install()
本地 django 连接 linux 上的数据库注意事项：
1. 防火墙问题，需配置规则，或者关闭防火墙
使用云服务器的同学，需要注意开通 3306 端口（安全组功能）
2. 远程连接 mysql，需要授权，远程连接
grant all privileges .....

redis
import redis

准备 django 项目 > crm 在服务器上运行 crm
1. 把本地代码，传至 linux
-scp(linux 与 linux 网络传输)
-xshell(yum install lrzsz) (windows)
lrzsz 可以通过如下俩命令管理文件，也可以直接拖拽文件
rz 接收
sz 发送
lrzsz 只适用于小文件，大文件，请用 xftp
-xftp (更为高效的企业级文件传输协议软件)
2.django 项目需要配置 allow_hosts=['*']，允许所有主机访问
debug=True #返回给项目一个 debug 信息，暴露了项目配置信息，因此在线上要关闭

 

Nginx
1.web 服务器，用户的统一入口，
我们的想法是，让用户通过 nginx 这个入口，就能访问到我们的应用服务器的功能
www.pythonav.cn 入口 < 80 端口
端口转发，反向代理
80 端口的请求 > 8000 的端口应用

server{} 虚拟主机

2. 反向代理服务器
proxy_pass 后端应用服务器的 ip:port (转发给一个单点机器)
proxy_pass upstream 负载均衡池
3. 负载均衡服务器
nginx 接收到了基于 wsgi 协议的动态请求，然后通过 uwsgi_pass 转发给 uwsgi 服务器
uwsgi_pass mydjango;

upstream mydjango {
server 192.168.12.1:8000 weight=1;
server 192.168.12.2:8000 weight=5;
server 192.168.12.3:8000 weight=10;
}
4. 处理静态文件，者是 nginx 的天然优势，处理静态文件的高并发性性能

www.pythonav.com/static/xxx.js
文件存放目录 /data/static/xxx.js
www.pythonav.com/static/xxx.css
文件存放目录 /data/static/xxx.css
www.pythonav.com/static/xxx.jpg
文件存放目录 /data/static/xxx.jpg

location /static {
alias /data/static;
}

 

uwsgi
uwsgi 服务器：
通过 uwsgi 这个软件启动 crm 项目，且是一个支持高并发，多进程的一个应用服务器
uwsgi --module crm
python3 manage.py runserver 0.0.0.0:8000 ×× 不再用这种单机形式启动 crm
django-admin startproject crm
django-admin startapp app01
crm
-crm
-wsgi.py (重点级的文件，django 启动，实现 wsgi 协议的文件)
-manage.py

常见问题：
uwsgi 启动 crm 的时候，非常有可能报错一个 no application(找不到应用)
uwsgi 找不到你的 crm 的 wsgi.py
其实 uwsgi 是通过这个 application 对象加载 crm 的
application = get_wsgi_application()

进程管理工具：
启动进程后，通过命令 手动管理
ps -ef |grep uwsgi
#启停 uwsgi
kill -9 pid
pkill uwsgi
killall uwsgi

#管理 nginx

ps -ef
kill

#管理 mysql
ps -ef

kill

#进程管理工具
supervisor 服务启动后

supervisorctl ，可以通过这个命令，非常方便的管理进程，也可以统一启动，停止所有的进程
批量管理进程
mysql : running/stop
nginx : running/stop
uwsgi:running/stop

项目发布配置手册：
(更换不同的服务器环境，首先就要解决环境依赖的问题)
1.pip3 frezz > requirements.py
2. pip3 install -r requirements.py
3.docker

项目发布配置手册：
(更换不同的服务器环境，首先就要解决环境依赖的问题)
1. 准备 python 环境，准备虚拟环境，激活了虚拟环境
mkvirtualenv cwcrm
检测是否虚拟环境正常
which pip3
which python3
2. 安装 django 模块（此时的操作都是在 nbcrm 这个虚拟环境下了）
pip3 install django==1.11.11

3. 安装 pymysql 连接 mysql 数据库
pip3 install pymysql
4. 安装 django 的一个 django-multiselectfield
pip3 install django-multiselectfield
5. 解决项目的数据库连接问题，修改 settings.py
1. 启动 linux 的数据库，创建对应的数据库，密码设置等等
mysql -uroot -p
create database mycrm;
2. 更改 settings.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'mycrm',
'HOST': '127.0.0.1',
'PORT': 3306,
'USER': 'root',
'PASSWORD': 'chenwei',
}
}
3. 更改允许主机
ALLOWED_HOSTS = ['*']

4. 线上关闭 debug(肖锋的这个 nb_crm 先别改 debug 了)，默认先用 True
debug=True
6. 启动项目
python3 manage.py runserver 0.0.0.0:9000
7. 浏览器访问
192.168.12.9:9000/login/
使用 uwsgi 启动 django
1. 安装 uwsgi
pip3 install -i https://pypi.douban.com/simple uwsgi

2. 通过 uwsgi 命令启动 python 应用
uwsgi --http 0.0.0.0:8888 --wsgi-file test1.py
--http 指明是 http 协议
--socket 启动一个 socket 链接
--wsgi-file 指明一个 python 应用文件
3. 通过 uwsgi 启动 django 项目 (问题是，uwsgi 不处理 static 静态文件的配置)
uwsgi --http :8888 --module CW_crm.wsgi
浏览器访问:192.168.12.9:8888
4.uwsgi 可以热加载项目
uwsgi --http :9999 --module CW_crm.wsgi --py-autoreload=1
--py-autoreload 是告诉 uwsgi 自动重启加载 django 项目

5. 通过 uwsgi 的配置文件启动项目
1. 手动创建 uwsgi.ini 文件
touch uwsgi.ini
2. 获取 home 路径
1. 激活虚拟环境 workon cwcrm
2. 进入虚拟环境 cdvirtualenv
3. 查看当前路径 pwd
3. 写入如下配置
[uwsgi]
#项目的绝对路径，定位到项目的第一层
chdir = /opt/CW_crm
#指明项目的 wsgi 文件路径
module = CW_crm.wsgi
#指明你的虚拟解释器的第一层路径
home = /root/Envs/cwcrm
#指明通过 uwsgi，启动多少个进程
processes = 5

#非常重要
#非常重要
#非常重要
#如果你已经配置了 nginx(启动了 nginx 服务，配置了 uwsgi_pass)，请用这个 socket 连接
#socket = 0.0.0.0:8000

#如果你没用 nginx，想通过 uwsgi 直接启动 web 服务，指明 http 协议
http = 0.0.0.0:9999

#在退出 uwsgi 环境后，清空环境变量
vacuum = true

6. 通过配置文件启动 CW_crm（注意 uwsgi 不会处理静态文件，如果有，也是浏览器的缓存！！！！）
uwsgi --ini uwsgi.ini

7. 配置 django 的 settings.py，收集所有 NB_crm 项目所需的静态文件
1.# 通过命令，收集整个项目所有的静态文件，放入到 /opt/static/
STATIC_ROOT='/opt/static/'
2. 执行命令
python3 manage.py collectstatic
3. 此时 CW_crm 的所有静态文件，都跑到 /opt/static/ 底下了
(nbcrm) [root@node1 /opt/CW_crm 11:09:33]#ls /opt/static/
admin css imgs js plugins
8. 配置 nginx
1. 配置一个网站入口，当用户访问 192.168.12.96:80 这个 web 应用时，自动将请求转发给 uwsgi，uwsgi 处理后，返回给 nginx，返回给用户
当请求是 192.168.12.96:80 的时候，其实访问的是 192.168.12.96:9999 这是动态请求，因为我是找到的 uwsgi
#匹配度最低的写法，因此就是任何的请求都访问到这里
2. 通过 nginx 去处理静态文件

3.nginx.conf 配置如下
vim /opt/nginx1-12/conf/nginx.conf
#定义负载均衡池，里面放入 uwsgi 的地址
upstream nbcrm {
server 127.0.0.1:8000;
}

server {
listen 80;
server_name www.s14huoying.com;
#讲 nginx 入口的请求，直接反向代理给 uwsgi
location / {
uwsgi_pass nbcrm;
include /opt/nginx1-12/conf/uwsgi_params;
}
#通过 nginx 处理 nbcrm 的静态文件
location /static {
alias /opt/static/;
}
}
4. 启动 nginx 服务
/opt/nginx1-12/sbin/nginx (确保 nginx 无进程 pkill nginx)
查看进程
ps -ef|grep nginx
9. 更改 uwsgi.ini ，指明 socket 连接，结合 uwsgi 和 nginx
#如果你已经配置了 nginx，请用这个 socket 连接
socket = 0.0.0.0:8000
10. 数据库迁移
python manage.py makemigrations
python manage.py migrate
数据迁移:
1. 将数据放入 dump.db
cmd-->mysqldump -uroot --databases mycrm > dump.db
2. 利用 Xftp 将 dump.db 导入到 liunx 中的 /opt/dump.db
3. 登录 linux 环境下的数据库 MariaDB
mysql -uroot -p
4. 获取数据
source /opt/dump.db
11. 启动 uwsgi.ini
uwsgi --ini uwsgi.ini

12. 启动 nginx
./nginx
并且访问 nginx 的域名入口，查看是否能访问到 uwsgi 项目，并且静态文件是否正常

www.s14huoying.com 查看浏览器状态

13. 配置 supversior，管理 uwsgi 进程

注意，请退出虚拟环境，在宿主机环境下，安装 supvervisor

1. 安装 easy_install ，python2 的软件包管理工具 ，如果有了可以忽略
yum install python-setuptools

#安装软件
easy_install supervisor

2. 使用 supervisor 命令, 常用命令如下
生成配置文件
echo_supervisord_conf > /etc/supervisord.conf
3. 修改配置文件，添加任务，按照自己的机器环境修改此命令
[program:s14cwcrm]
#启动 uwsgi 的命令就是这个
command=/root/Envs/cwcrm/bin/uwsgi --ini /opt/CW_crm12╜╔╖╤╝╟┬╝/uwsgi.ini
#自动启动 uwsgi，挂了之后自动加载
autorestart=true
4. 启动 supvervisord 服务，启动 uwsgi
#服务端命令，用于启动这个服务
supervisord -c /etc/supervisord.conf

5. 通过命令管理 uwsgi
直接回车，进入交互式 supervisorctl 管理状态

[root@node1 ~ 11:53:32]#supervisorctl
s14nbcrm RUNNING pid 2008, uptime 0:01:56

也可以通过命令交互式的管理 uwsgi
#服务端启动后，通过命令管理软件

supervisorctl start s14cwcrm
supervisorctl stop s14cwcrm
supervisorctl status s14cwcrm
day111Linux 笔记

redis 哨兵博客地址：
https://www.cnblogs.com/pyyu/p/9718679.html
redis-cluster 博客
https://www.cnblogs.com/pyyu/p/9844093.html
docker 博客：
https://www.cnblogs.com/pyyu/p/9485268.html

内容回顾
redis

1. 安装配置 redis
redis.conf 放哪都可以 编译安装的话，就在 redis 源码的目录
port 6379
bind 0.0.0.0
dir 指明 redis 数据文件存放路径
daemonize yes #将 redis 在后台运行，不占用一个终端
protomode yes #安装模式
requirepeass s1466 #redis 密码登录
pidfile #存放 redis 进程 id 的文件

RDB 持久化的参数
AOF 持久化的参数

#指明 master 的 ip 和端口信息
slaveof 127.0.0.1 6380

#redis 支持多实例
redis-server redis-6379.conf
redis-server redis-6380.conf
redis-server redis-6381.conf

#发布订阅
发布者
订阅者
频道

#主从同步
redis 主从
优先
1. 保证数据安全，主从机器两份数据
一主多从
2. 读写分离，缓解主库压力
主 redis，可读可写
slave 身份，只读

 

缺点
1. 手动主从切换
假如主库挂了，得手动切换
master 192.168.12.10 挂了

slave1 192.168.12.11 主库挂了，我得手动选一个 slave 为新的 master
1. 配置主库地址
slaveof 192.168.12.12 6380

slave2 192.168.12.12
1. 取消 12 的从库身份
slaveof no one
2. 准备一个值班人，他去检测，redis 主从机制，是否宕机，值班人来做这个主从切换的事

redis 哨兵配置：
1. 准备 3 个 redis 实例文件
touch redis-6379.conf
touch redis-6380.conf
touch redis-6381.conf
2. 配置文件内容如下
vim redis-6379.conf
vim redis-6380.conf
vim redis-6381.conf
port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data/"
daemonize yes
#其余 6380、6381 配置文件，端口确保不同，且配置上主从参数
slaveof 127.0.0.1 6379
查看配置文件
cat redis-6379.conf
cat redis-6380.conf
cat redis-6381.conf
创建存放路径文件夹
mkdir -p /var/redis/data/
3. 启动三个 redis 实例
redis-server redis-6379.conf
redis-server redis-6380.conf
redis-server redis-6381.conf

4. 检查三个 redis 实例的主从身份关系
redis-cli -p 6379 info replication
redis-cli -p 6380 info replication
redis-cli -p 6381 info replication

5. 配置三个哨兵
touch redis-sentinel-26379.conf
touch redis-sentinel-26380.conf
touch redis-sentinel-26381.conf

6. 哨兵配置文件，几乎一致，仅有端口区别
vim redis-sentinel-26379.conf
vim redis-sentinel-26380.conf
vim redis-sentinel-26381.conf
// Sentinel 节点的端口
port 26379
dir /var/redis/data/
logfile "26379.log"
daemonize yes
// 当前 Sentinel 节点监控 127.0.0.1:6379 这个主节点
// 2 代表判断主节点失败至少需要 2 个 Sentinel 节点节点同意
// mymaster 是主节点的别名
sentinel monitor mymaster 127.0.0.1 6379 2

// 每个 Sentinel 节点都要定期 PING 命令来判断 Redis 数据节点和其余 Sentinel 节点是否可达，如果超过 30000 毫秒 30s 且没有回复，则判定不可达
sentinel down-after-milliseconds mymaster 30000

// 当 Sentinel 节点集合对主节点故障判定达成一致时，Sentinel 领导者节点会做故障转移操作，选出新的主节点，
// 原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为 1
sentinel parallel-syncs mymaster 1

// 故障转移超时时间为 180000 毫秒
sentinel failover-timeout mymaster 180000
7. 启动三个 redis 哨兵
redis-sentinel redis-sentinel-26379.conf
redis-sentinel redis-sentinel-26380.conf
redis-sentinel redis-sentinel-26381.conf
8. 检查 redis 哨兵是否连接, 产看哨兵身份信息，检查主从节点健康状态
redis-cli -p 26379 ping-->PONG
redis-cli -p 26380
redis-cli -p 26381
redis-cli -p 26379 info sentinel
redis-cli -p 26380 info sentinel
redis-cli -p 26381 info sentinel
9. 配置正确后，杀死 master 节点，查看主从身份切换是否正常
查看配置文件
cat redis-6379.conf
port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data/"
daemonize yes

cat redis-6380.conf
port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data"
slaveof 127.0.0.1 6381
cat redis-6381.conf
port 6381
daemonize yes
logfile "6381.log"
dbfilename "dump-6381.rdb"
dir "/var/redis/data"
检查三个 redis 实例的主从身份关系
redis-cli -p 6379 info replication
redis-cli -p 6380 info replication
redis-cli -p 6381 info replication

1,2,3,4,5,6...100

1%3 1 将余数为 1 分给一匹马
2%3 2 讲余数为 2 的分给马 2
3%3 0 余数为 0 的分给马 3

ruby 语言脚本，一键自动安装 redis-cluster

redis-cluster 就是什么
将我所有的数据，keys *
分配 6 匹马，6 匹马的身份信息

3 个主 3 个从
redis-cluster 使用的哈希槽算法，将数据分为 0~16383 的槽位
将所有的 keys 分配到这些槽位当中

安装配置手册
1. 准备 6 个 redis 节点，也就是准备 6 匹马
redis 可以自定制端口，你可以用 6379，也可以用 7000
touch redis-7000.conf
touch redis-7001.conf
touch redis-7002.conf
touch redis-7003.conf
touch redis-7004.conf
touch redis-7005.conf
2. 创建配置文件存放文件路径文件夹
mkdir -p /opt/redis/data
3. 准备 6 个配置文件 redis.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
cluster-require-full-coverage no
cat redis-7000.conf > redis-7001.conf
cat redis-7000.conf > redis-7002.conf
cat redis-7000.conf > redis-7003.conf
cat redis-7000.conf > redis-7004.conf
cat redis-7000.conf > redis-7005.conf

4. 查看 redis 配置文件，修改这 6 个文件的端口不同
sed 's/7000/7001/g' redis-7000.conf
#此时还未生效，只返回处理结果, 所以: 加上 -i 参数，写入到文件 insert
sed -i 's/7000/7001/g' redis-7000.conf #对这个文件修改
#修改之后重定向写入新文件
sed 's/7000/7001/g' redis-7000.conf > redis-7001.conf
#sed-->linux 处理字符串的命令
# 's/7000/7001/g'
# 第二空格 --> 放入你想替换的内容
# s--> 代表替换指令
# / 你想换的内容 / 你想替换后的内容 /
# g 全局替换 globol
# redis-7000.conf 操作的对象，将这个文件内的所有 7000 替换为 7001
sed 命令快速生成端口不同的配置文件
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
查看配置信息
cat redis-7000.conf
cat redis-7001.conf
cat redis-7002.conf
cat redis-7003.conf
cat redis-7004.conf
cat redis-7005.conf

5. 启动 6 个 redis 实例 (启动之前确保 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

6. 检查 redis 进程信息
ps -ef|grep redis
root 9478 1 0 10:04 ? 00:00:00 redis-server *:7000 [cluster]
root 9483 1 0 10:04 ? 00:00:00 redis-server *:7001 [cluster]
root 9490 1 0 10:04 ? 00:00:00 redis-server *:7002 [cluster]
root 9495 1 0 10:04 ? 00:00:00 redis-server *:7003 [cluster]
root 9500 1 0 10:04 ? 00:00:00 redis-server *:7004 [cluster]
root 9505 1 0 10:04 ? 00:00:00 redis-server *:7005 [cluster]

7. 安装配置 ruby 环境，用于一键搭建 redis 集群
1. 下载源码
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
2. 解压缩 ruby
tar -xvf ruby-2.3.1.tar.gz
3. 编译安装 ruby
指定安装目录
./configure --prefix=/opt/redis-4.0.10/mycolony
make && make install
8. 准备 ruby 的环境变量
cp ./bin/ruby /usr/local/bin/
cp ./bin/gem /usr/local/bin
查看环境变量
echo $PATH
9. 下载 ruby 的软件包管理工具
wget http://rubygems.org/downloads/redis-3.3.0.gem
gem install -l redis-3.3.0.gem #安装 ruby 操作 redis 的模块

10. 查看 ruby 语言的包有哪些
gem list -- check redis gem

11. 配置环境变量 redis-trib.rb，用于创建 redis-cluster
#找到这个 redis-trib.rb 命令在哪里
[root@node1 /opt/redis-4.0.10/src 10:28:32]#find /opt -name redis-trib.rb
/opt/redis-4.0.10/src/redis-trib.rb
#配置环境变量，用于快速执行 redis-trib.rb 这个命令
cp /opt/redis-4.0.10/src/redis-trib.rb /usr/local/bin/

12. 通过 redis-trib.rb 命令，一键创建 redis-cluster 集群功能
#其实就是分配槽位，分配主从关系
#通过这个命令，创建集群功能
#1 代表每个主只有一个从
#自动给后面 6 个节点，分配主从关系，7000、7001、7002 是主节点，7003、7004、7005 是从节点
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
1: 代表每个主节点只有一个主节点
13. 连接 redis 服务, 开启集群功能
redis-cli -c -p 7000
-c 代表开启集群功能
14. 写入数据来使用 redis 集群了
redis 查看身份的命令，可以来检查集群的节点身份信息
redis-cli -p 7003 info replication #查看主从身份信息
redis-cli -p 7004 info replication #查看主从身份信息
redis-cli -p 7005 info replication #查看主从身份信息

#查看 redis 集群状态信息
redis-cli -p 7000 cluster info #查看节点集群状态

#redis 操作集群数据
# 通过 -c 参数才能指定集群功能
redis-cli -p 7000 -c
主节点 --> 从节点:
7000-->7003
7001-->7004
7002-->7005
set name cw ---> 根据槽位数值决定重定向节点
服务器环境

第一代：服务器 + centos
第二代：服务器 +windows+vmware workstation（学习版）+centos7 机器垃圾，只能安装 10 个以内的虚拟机 + django 应用
dell poweer ege R720
实体服务器，26 台，托管在上海世纪互联机房托管中心
还有自建机房（5 台内网服务器）
通过 R720 实体服务器，通过 vmware esxi(支持 windows，linux)
虚拟化出 280+ 的 linux 操作系统
100+redhat
100+centos
服务器环境分为三个阶段
线上服务器 (对客户提供服务)
即将上线服务器（测试环境）
本地测试代码环境（）
服务器 +vmware esxi（企业版虚拟化 )+linux
+centos
+redhat
+suse
第三代: 服务器 + opnstatck 云虚拟化

第四代：服务器 + vmware esxi + docker + django 应用

我们个人学习 笔记本 +vmware +centos+docker +django

解决环境依赖的问题
1. 虚拟机，定制操作系统模板
vmware esxi 定制一个 centos 镜像板块，我在这模板中定制我的功能，安装 vim 安装 python3 安装 django
通过镜像模块安装系统，也可以解决环境依赖的问题

docker 容器三大概念 (docker 整个生命周期)
docker 三大概念：
容器 container（如同通过 class 类的实例化对象），也就是可以通过一个镜像，创建多个容器实例
镜像 image(如同 class 类)
仓库 repository (存放镜像文件的地方) 我可以去公网去，下载镜像
为什么要用 docker:
之前的服务器部署成本高, 部署慢, 资源浪费, 难于迁移和扩展, 可能被限定硬件厂商
#centos 安装 docker
1. 编译安装，源码安装或者利用 rpm 安装

2.yum 安装
#如果网速太慢，你可以选择阿里云的源，缺点就是版本低
#你可以选择用 aliyun 的 yum 源，docker 就存在 epel 源中
#如果网速够快，或者在公司中，一定要装官方源
#配置 docker 的官方源，一定是官方的最好啊
#官网安装
1. 卸载旧版本
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine

2. 设置存储库
sudo yum install -y yum-utils \
device-mapper-persistent-data \
lvm2

sudo yum-config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
3. 安装 docker 社区版
sudo yum install docker-ce
4. 启动关闭 docker
systemctl start docker
#阿里云安装
1. 安装 docker 服务端
yum install docker* docker-* -y
2. 启动 docker
systemctl start docker
systemctl status docker
3. 查看 docker 是否正确启动
docker version
4. 简单使用 docker
docker search centos #搜索所有 centos 的 docker 镜像
docker search hello-world
docker pull centos #获取 centos 镜像
docker pull hello-world #获取 hello-world 镜像
docker pull ubuntu #获取 ubuntu 镜像

docker image ls #查看镜像
#等于
docker images #查看镜像
docker run 镜像名 / 镜像 id（可以写前三位） #运行一个 docker 容器实例
docker ps #查看 docker 进程
docker ps -a #查看所有运行过的 docker 容器记录

docker 常用命令：
增:
增加容器记录，启动容器
docker run 镜像 id/ 镜像名 #运行创建一个容器 container 实例
docker run -it centos #此命令会 进入到容器空间内，进入到容器的 centos 中
-i 交互式界面
-t 是开启一个终端

docker run -it --rm ubuntu #运行一个乌班图容器，并且在退出时，删除容器运行记录

docker run centos
#直接运行这个 centos 镜像，会生成一个容器记录
#此时就会生成一个容器记录，但是容器中并没有任何的后台程序，因此直接就挂掉
# 你会发现，容器死活不生成，docker ps 看不到记录，

docker run -d centos /bin/sh -c "while true;do echo hello s14 docker~~~~; sleep 1;done"
#一定会生成一个容器记录
#docker ps 能不能看到记录？
-d 参数是 后台运行
/bin/sh 调用 shell 解释器
-c 指明一段 shell 语法

删:
docker rm 容器 id #docker rm 删除的是已经停止的容器 id

docker rmi 镜像 id #删除一个镜像记录

docker rm `docker ps -aq` # 一次性删除所有容器 id 记录
` ` #反引号是取命令的运行结果

docker rmi `docker images -aq` #一次性删除所有镜像记录

改:
docker commit #提供容器记录，为新的镜像
docker stop 容器 id #停止正在运行的容器
docker start 容器 id #启动一个关闭中的容器

查:
docker image ls #查看镜像记录
docker images #查看镜像记录

docker ps #查看容器记录 ，只能查看到正在运行中的容器
#正在运行中的容器，代表，容器后台一定有个进程在运行
docker ps -a #查看停止的和在运行的容器记录
docker container ls -a #等同于 docker ps -a
docker logs -f 容器 id #查看正在运行中的 容器内日志
-f 不间断打印
#导出镜像
docker save centos > /opt/centos.tar.gz #导出 docker 镜像至本地

#导入镜像
docker load < /opt/centos.tar.gz
#通过 --name 参数给容器记录，加上别名
docker run --name chenwei -d centos /bin/sh -c "while true;do echo hello s14 docker~~~~; sleep 1;done"

#进入正在运行的容器
docker exec -it c49 /bin/bash

-it 交互式的操作终端
/bin/bash 使用 shell 解释器，只有在 redhat，centos 系统中，才能用 /bin/bash

#提交自定义的镜像文件（自己修改了容器记录，提交成一个新的镜像，可以发给别人使用）
1. 默认的 centos 镜像，没有 vim
进入镜像
docker run -it centos /bin/bash
安装 vim
yum install vim -y
查看容器进程记录
docker ps -a
2. 我们自己 run 一个容器记录，安装 vim，然后提交成新的镜像文件
docker commit 435866a528d0 s14/centos-vim

3. 查看新的镜像记录
docker images
s14/centos-vim latest 01b0298ec5b0 7 seconds ago 327 MB

4. 可以通过新的带有 vim 的镜像运行容器记录，通过此方法可以解决环境难配置的问题
docker run -it s14/centos-vim /bin/bash

#容器内应用，外部也是可以访问的
#通过 -p 参数进行端口映射
-p(小写): 宿主机端口: 容器内端口
-P(大写): 随机映射一个容器内端口
#运行一个 web 容器实例
1. 下载镜像
docker pull training/webapp
2. 运行镜像，产生容器记录
docker run -d -P 6fa python app.py
-d 后台运行
-P 将容器内的 5000 端口随机映射到宿主机的一个端口
docker ps
d1ca9de081c9 6fa "python app.py" 13 seconds ago Up 9 seconds 0.0.0.0:32768->5000/tcp nifty_diffie

3.docker port 容器 id
[root@node1 /opt/redis-4.0.10/src 16:00:41]#docker port d1ca9de081c9
5000/tcp -> 0.0.0.0:32768

4. 浏览器访问
192.168.12.9:32768
5.-p(小) 指定端口执行
docker run -d -p 9000:5000 6fa python app.py
6. 浏览器访问
192.168.12.9:9000
#docker 镜像加速器
#执行命令
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io
#其实就是更改了，docker 的一个仓库源
[root@node1 /opt/redis-4.0.10/src 14:48:26]#cat /etc/docker/daemon.json
{
"registry-mirrors": [
"http://95822026.m.daocloud.io"
],
"insecure-registries": []
}

day112Linux 笔记

昨日内容回顾：

1.redis 主从同步
可以主从数据同步，从库只读，只能手动切换主备关系
2.redis 哨兵
- 准备 redis 主从数据库环境
- 准备 redis 哨兵 (可以有一个，可以有多个)
- 哨兵检测 redis 主库状态，主库挂了的话，找一个从库顶替
3.redis-cluster(redis3.0 之后，官方提供的集群方案)
- 主从 + 哨兵
-codis(redis 集群方案，豆瓣的开发，开源的软件)

1.docker 介绍
docker 是 linux 容器方案
docker 可以很大的解决环境依赖问题

virtualenv 是什么？
python 解释器的虚拟环境，和操作系统无关
在机器上可以配置多个 python 解释器

docker 环境依赖解决问题：
1. 在物理操作系统上的一个环境隔离（虚拟环境）

docker 使用命令回顾：
镜像
docker image ls
docker images
docker pull 镜像名 #docker 仓库，dockerhub
docker push 镜像名 #把本地的镜像推送到 dockerhub 仓库
docker search 镜像名
docker rmi 删除镜像
docker version #查看 docker 版本，查看到 server 和 client 两个端
systemctl start docker #启动 docker
docker save 镜像名 > /data/centos.tar.gz #导出镜像
docker load < /data/centos.tar.gz #导入镜像
docker run 镜像名 #运行镜像文件，产生一个容器实例

容器
docker start 容器 id
docker stop 容器 id
docker exec -it 容器 id #进入正在运行的容器
-i 交互式操作
-t 开启一个终端

docker run 镜像名 #创建容器实例
docker rm 容器 id #删除容器记录，必须提前 docker stop 容器 id ，只能杀死已经停止的容器
docker ps #查看容器正在运行记录
docker ps -aq #显示所有容器记录的 id 号
-a 显示所有容器记录
-q 显示容器 id
docker rm `docker ps -aq` #一次性删除所有容器记录

docker container ls #查看容器正在运行记录
docker commit 容器 id 记录 #提交这个容器，创建一个新的镜像
docker logs #查看容器运行日志
-f #不间断打印容器日志
docker port #查看容器的端口映射关系 (外部访问到容器内的端口)
docker run -d centos -P
-d 后台运行
-P 随机映射端口
-p 9000(宿主机):5000(容器内)
--name 给创建的容器记录，添加别名

仓库
1.docker pull

2.docker run #如果没有这个镜像，直接 docker run 它也会内部去下载这个镜像

#脚本的概念就是，将你想做的事，写入到一个文件中，然后执行这个文件，就是执行一个脚本

#假如我想定制一个自己的 docker 镜像
#首先得有一个基础操作系统镜像
#FROM centos #基于这个 centos 的镜像，然后定制我自己的镜像
#底下通过 docker 提供的指令，添加，自定制自己的规则，然后创建自己的镜像文件
#FROM centos #基于这个 centos 的镜像，然后定制我自己的镜像
#RUN yum install vim -y
#RUN yum install nginx -y

#仅仅只有这 3 句的 dockerfile，就能定制一个拥有 nginx 和 vim 的 centos 镜像文件
#此时我构建出的这个 centos-vim-nginx 镜像文件，就可以传给 14 期的所有同学用
#咱们 14 期的同学，就可以 docker load 或者 docker pull 这个镜像，docker run centos-vim-nginx

FROM scratch #制作 base image 基础镜像，尽量使用官方的 image 作为 base image
FROM centos #使用 base image
FROM ubuntu:14.04 #带有 tag 的 base image

#相当于代码注释，告诉别人，你的镜像文件的信息是什么
LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
#定义一个 dockerfile 的作者信息
LABEL maintainer="wupeiqidsb"

#开始定制自己的镜像需求
#对于复杂的 RUN 命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
RUN yum update && yum install -y vim \
Python-dev #反斜线换行
#RUN 指令，相当于在 centos 中执行了一堆命令
RUN hostnamectl set-hostname mydocker
RUN yum install redis -y
#写上 3 条就会执行者 3 条

WORKDIR /root #相当于 linux 的 cd 命令，改变目录，尽量使用绝对路径！！！不要用 RUN cd
WORKDIR /test #如果没有就自动创建
WORKDIR demo #再进入 demo 文件夹
WORKDIR s14
WORKDIR /opt
RUN pwd #结果 /opt

#ADD 和 COPY
#宿主机 linux 有自己的磁盘，文件夹
#容器空间 也有自己的文件夹
#我们使用 docker 一定是想将宿主机的文件，添加到容器中
#ADD 就是添加宿主机的文件，到容器当中
#ADD 还有一个解压缩的功能

ADD and COPY
#把宿主机的 hello 文件，放入到容器的 / 根目录下
# 这个 hello 文件的相对路径，是以 Dockerfile 文件所在目录为相对路径

ADD hello / #把本地文件添加到镜像中，吧本地的 hello 可执行文件拷贝到镜像的 / 目录

#把与 dockerfile 同级的一个 test.tar.gz 压缩文件，拷贝添加到容器的 根 / 目录中，并且解压缩
# 远程传输 并且 tar -zxvf
ADD test.tar.gz / #添加到根目录并解压

WORKDIR /root #切换工作目录到 /root

#把 dockerfile 同级的那个 hello 文件 拷贝到容器的 /root/test/hello
ADD hello test/ #进入 /root/ 添加 hello 可执行命令到 test 目录下，也就是 /root/test/hello 一个绝对路径
COPY hello test/ #等同于上述 ADD 效果

ADD 与 COPY
-ADD 除了 COPY 功能还有解压功能

添加远程文件 / 目录使用 curl 或 wget

ENV #环境变量，尽可能使用 ENV 增加可维护性
ENV MYSQL_VERSION 5.6 #设置一个 mysql 常量
RUN yum install -y mysql-server=“${MYSQL_VERSION}”

RUN ./cofigure --prefix=/opt/
RUN make&& make install

#dockerfile 实验
cd /data/mydocker
touch myflask.py
touch Dockerfile
1. 准备一个 flask 代码，准备 python 代码
vim myflask.py
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
return "hello docker,i am sbwueiqi, i am in s14"
if __name__=="__main__":
app.run(host='0.0.0.0',port=8080)
开启镜像
docker start 94d
进入 docker 容器
docker exec -it 94d /bin/bash
安装
yum install net-tools -y
查看 ip
ifconfig
172.17.0.1
exit
回到宿主机环境
ip route
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1
2. 准备 Dockerfile，准备好所有需要的文件
ls /etc/yum.repos.d/
cp /etc/yum.repos.d/CentOS-Base.repo .
cp /etc/yum.repos.d/epel.repo .
.--> 代表 /data/mydocker
[root@node1 /data/mydocker 10:33:53]#ls
CentOS-Base.repo Dockerfile epel.repo myflask.py
vim Dockerfile
FROM centos
LABEL maintainer="Chao Yu<yc_uuu@163.com>"
ADD CentOS-Base.repo /etc/yum.repos.d/
ADD epel.repo /etc/yum.repos.d/
RUN yum clean all
RUN yum install python-pip -y
RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple flask
COPY myflask.py /app/
WORKDIR /app
EXPOSE 8080
CMD ["python","myflask.py"]
1. 引入一个 centos 镜像，为基础镜像
2. 作者注释信息
3. 添加本地的两个 yum 文件，到容器的 /etc/yum.repos.d/ 底下
4. 清空 yum 缓存
5.yum 安装 pip 工具
6.pip 安装 flask 模块，指定清华源
7. 拷贝本地的 flask 代码，到容器的 /app/ 目录下
8. 切换工作目录，到 /app 底下
9. 暴露容器的 8080 端口，然后在运行镜像时候，加上 -p 参数，指定端口映射
10. 执行命令，运行 flask
3. 构建 docker 镜像文件
docker build -t chenwei666/s14-flask-docker .
#构建当前目录的 Dcokerfile，然后构建出一个名为 chenwei666/s14-flask-docker 这个的镜像文件
-t tag 参数，给镜像加上标记名
dockerhub 账户名：chenwei666

dockerhub 账户名 / 镜像名 #是为了后面讲 docker 镜像，推送到 dockerhub

4. 查看镜像是否构建完成
docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
chenwei666/s14-flask-docker latest ce18e41322bc 16 seconds ago 374MB
<none> <none> 4b7a3fccda22 25 minutes ago 202MB
s14/centos-vim latest 2f507be2f508 9 hours ago 327MB
centos latest 1e1148e4cc2c 6 days ago 202MB
ubuntu latest 93fd78260bd1 3 weeks ago 86.2MB
hello-world latest 4ab4c602aa5e 3 months ago 1.84kB
training/webapp latest 6fae60ef3446 3 years ago 349MB

5. 运行这个镜像文件，产生容器实例
docker run -p 9000:8080 -d ce18e41322bc
-p 映射 9000 端口到容器的 8080
-d 后台运行
43d 镜像 id

6. 查看已经运行的 docker 实例
docker ps
[root@cwlinux /data/mydocker 21:45:37]#docker port 7f3d2e335106
8080/tcp -> 0.0.0.0:9000
浏览器访问
192.168.12.9:9000
7. 学习 dockerhub，发布自己的 docker 镜像
1. 我可以先下载其他人的 docker 镜像
docker pull yuchao163/hello-world-docker
2. 登录
docker login
登录
docker login
用户名:chenwei666
密 码:
3. 修改名字
docker imags
docker tag yuchao163/hello-world-docker chenwei666/hello-world-docker
4. 上传自己的 docker 镜像
docker push chenwei666/hello-world-docker
5. 登录 https://hub.docker.com/ 查看自己推送的公网镜像
8. 构建公司私有 docker 仓库, 其实就是搭建一个 api 服务器, 通过 api 可以下载镜像
1. 下载 docker 官方提供的私有仓库镜像
docker pull registry
2. 查看镜像
docker images
3. 启动 registry 私有仓库容器
docker run -d \
-p 5000:5000 \
-v /data/mydocker:/var/lib/registry \
registry
#docker 的数据集挂载功能
#-v 参数 挂载宿主机的文件: 容器内的文件夹
# -v /data/mydocker:/opt/s14
#私有仓库会被创建在容器的 /var/lib/registry 下，因此通过 -v 参数将镜像文件存储到本地的 /data/mydocker/registry 下
#端口映射容器中的 5000 端口到宿主机的 5000 端口
#验证:
#1. 查看镜像
# docker images
# chenwei666/s14-flask-docker latest ce18e41322bc 16 hours ago 374MB
#2. 运行 flask 程序
# docker run -d -p 8000:8080 -v /opt/s14:/opt/data/ ce18e41322bc
#3. 查看进程获取 id
# docker ps
#4. 创建一个文件
# cd /opt/s14/
# touch hahahh.text
#5. 进入 docker 容器 --a0c 为容器 id
# docker exec -it a0c /bin/bash
#6.cd /opt/data
# ls ---> 此时目录下有一个 hahahh.text 文件
4. 检查启动的 registry 容器
docker ps
5. 测试连接容器
安装 telnet
yum install telnet -y
测试 5000 端口是否通信
telnet 192.168.12.13 5000
6. 访问浏览器
192.168.12.13:5000/v2/_catalog
返回
{"repositories":[]}
7. 传数据,Docker 默认不允许非 HTTPS 方式推送镜像。
我们可以通过 Docker 的配置选项来取消这个限制，这里必须写正确 json 数据
1.vim /etc/docker/daemon.json
{"registry-mirrors": ["http://f1361db2.m.daocloud.io"],
"insecure-registries":["192.168.12.13:5000"]
}
2. 写入到 docker 服务中，写入到 [Service] 配置块中，加载此配置文件
vim /lib/systemd/system/docker.service
[Service]
EnvironmentFile=/etc/docker/daemon.json

8. 重启 docker
systemctl restart docker
systemctl daemon-reload
systemctl restart docker
此时 docker 容器关闭了
1.docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cae29f88c632 registry "/entrypoint.sh /etc…" About an hour ago Exited (2) 5 minutes ago cocky_jepsen
2. 启动 docker 容器
docker start cae
3. 查看容器是否启动
ocker ps
9. 推送本地镜像到私有仓库
docker tag yuchao163/hello-world-docker 192.168.12.13:5000/s14-nihao
docker push 192.168.12.13:5000/s14-nihao
10. 浏览器访问查看私有接口的数据
192.168.12.13:5000/v2/_catalog
返回
{"repositories":["s14-nihao"]}
11. 删除本地镜像 192.168.12.13:5000/s14-nihao
docker rmi 192.168.12.13:5000/s14-nihao
12. 从私有仓库下载
docker pull 192.168.12.13:5000/s14-nihao

day113
今日内容：

saltstack 博客地址：
https://www.cnblogs.com/pyyu/p/9465608.html
在线 yaml 文件编写：
http://www.bejson.com/validators/yaml_editor/
saltstack 博客地址：
https://www.cnblogs.com/pyyu/p/9465608.html
python 的开发领域
django/flask/tornado/sanic/ 后台开发
django rest framewokr 写 api 接口数据
编写机器人调用脚本 flask+ 人工智能 ，有一个是机器人手臂
运维开发领域 cmdb 平台开发 (slatstack/ansible + django 提供页面 +mysql) 资产管理平台，运维开发人员，编写 cmdb，提供数据展示
监控平台二次开发 zabbix 二开 nagios 二次开发 ，都去了小米，二次开发 open-falcon(golang) 一个监控产品
k8s 二次开发业务开发 python/golang
代码发布平台 git+django+jenkins

红蜘蛛软件
c/s 架构

client : 学生端是客户端 ，装了红蜘蛛客户端 - 学生端
server 端： 教师机 ，装了红蜘蛛软件 - 教师端
教师机，只能管理， 教师机和学生机，相互通信，相互知道的情况下
#运维管理工具
ansible #支持 ssh，不需要客户端
saltstack #也是只是 ssh，不需要客户端的
安装架构是，master /minion
安装 salt 的依赖模块
python
zeromq 是一个消息队列 ，master 和 minion 通信，需要将 master 发送的命令，放入一个队列中
rabbitmq
rpc 远程消息调用
pyzmp
pycrypto
msgpack-python
yaml
- 是一个新兴的语法格式
salt
ansible
python
k8s
都是遵循 yaml 语法的配置文件格式
jinja2
模板语言
#服务器环境准备
1.master 讲师机
ip 192.168.12.96 node1 安装 salt-master

2. 准备多个客户端，被管控端，学生机安装 salt-minion
192.168.12.89 minion1
192.168.12.121 minion2
192.168.12.8 minion3

3. 关闭所有节点的防火墙，以免影响实验
iptables -F
systemctl stop firewalld
关闭 selinux

4. 配置本地文件解析，用于加速身份验证 编辑 /etc/hosts
通过主机名通信
vim /etc/hosts 写入
192.168.12.96 node1
192.168.12.89 minion1
192.168.12.121 minion2
192.168.12.8 minion3
ping 查看节点是否接通
ping node1
ping minion1
ping minion2
ping minion3
5. 确保环境准备 ok，确保每个节点的 yum 源配置正确
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum clean all #清空缓存
yum makecache #生成 yum 缓存

6. 安装 salt 软件
1.node1 端安装 salt-master
yum install salt-master -y

2. 在 3 个 minion 地址中安装 salt-minion
yum install salt-minion -y

7. 修改 master 和 minion 的配置文件
1.master 的配置文件
vim /etc/salt/master
interface: 0.0.0.0 #绑定到本地的 0.0.0.0 地址
publish_port: 4505　　# 管理端口，命令发送
user: root　　　　　　# 运行 salt 进程的用户
worker_threads: 5　　#salt 运行线程数，线程越多处理速度越快，不要超过 cpu 个数
ret_port: 4506　　# 执行结果返回端口
pidfile: /var/run/salt-master.pid #pid 文件位置
log_file: /var/log/salt/master　　# 日志文件地址

#自动接收 minion 的 key
auto_accept: False
2. 三个 minion 的配置文件
vim /etc/salt/minion
master: node1
master_port: 4506
user: root
id: s14minion1 #表示 minion 身份信息的，这里要修改，三个节点，为不同的 id
acceptance_wait_time: 10
log_file: /var/log/salt/minion
8. 启动 salt-master 和 salt-minion
systemctl start salt-master
systemctl start salt-minion
9. 在 salt 软件启动的时候，会进行通信连接，master 可以检测到 minion 的身份地址，
此时还未接收 key，还未通信，需要认证秘钥才可以通信
salt-key -L #查看所有主机秘钥信息
#salt-key 参数解析
-L #查看 KEY 状态
-A #允许所有
-D #删除所有
-a #认证指定的 key
-d #删除指定的 key
-r #注销掉指定 key（该状态为未被认证）
salt-key -a minion-id #指明接收一个 minion
salt-key -A # 接收所有 minion 的秘钥
salt "*" test.ping #通过 salt 主命令 匹配所有的已接收的主机 发送 ping 命令，会得到 True 或 false
salt "*" cmd.run #通过执行命令接口，对所有主机，执行命令
salt "*" cmd.run "touch /tmp/s14haha"
salt "*" cmd.run "yum install nginx -y #对所有主机发送安装 nginx 的命令
#在秘钥通信之前，最好进行秘钥检验
master 端：
salt-key -f 指明节点 id #查看节点的秘钥信息
minion 端：
salt-call --local key.finger #查看自己的秘钥信息，与 master 端的进行对比
10.salt 常用命令
1.salt 的命令直接输入，叫做执行模块
2.saltstack 提供了自己的脚本语言 s14salt.sls ，状态模块
3.salt 的命令语法格式
salt --summary '*' cmd.run 'yum remove nginx -y'
--summary 是返回 salt 命令的执行成功状态
"*" 目标匹配字符串
cmd.run 模块函数，对所有匹配到的机器，执行后面的参数
'yum remove nginx -y' #参数如下

salt --out=json '*' cmd.run_all 'hostname'
--out=json #返回 salt 执行结果为 json 格式 #json 数据反馈给 API

salt "*" cmd.run "ls /tmp"

salt "*" cmd.run_all "ls /tmp"
#cmd.run 和 cdm.run_all 是返回结果的详细的差别

#目标定位字符串
salt 's14minion[1,2,3]' pkg.version redis

's14minion[1,2,3]' #匹配 s14minion1、s14minion2、s14minion3
salt 's14minion[1,2,3]' pkg.download redis# 只下载 redis 的 rpm 包，不安装这是 pkg.download 函数的功能

pkg 模块对应着 yum 工具
pkg.install
pkg.version
pkg.remove
pkg.version

#列出 pkg 所有的方法
salt '*' sys.list_functions pkg
#service 模块，练习远程安装启动 nginx
salt 's14minion[1,2,3]' pkg.install nginx

salt "*" service.status/start/stop/restart nginx
#通过 service 模块管理服务

#命令执行结果，返回为 yaml
salt --out=yaml "*" service.status nginx

#yaml 语言解析
在线 yaml 配置文件编写
http://www.bejson.com/validators/yaml_editor/

#yaml 语法
#yaml 的对象，就是 python 的字典通过冒号指明字典
#yaml 的数组，就是 python 的列表，通过 横杠 表示 -
#作用域通过缩进层级关系区分
#空格数量保持一致即可，不要求是几个，默认是 2 个空格

s14:
男同学:
- kangchen
- xiaoma
- xiaoyu
女同学:
- wengang
- wengang2
- xiaowengang3
#对应的 python 数据结构
{ s14:
{'男同学': [ 'kangchen', 'xiaoma', 'xiaoyu'],
'女同学': ['wengang', 'wengang2', 'xiaowengang3'] } }
#salt 直接在命令行输入的命令，叫做
在命令行输入的命令都是 ---> 执行模块

等到命令写入到文件中 ----> 就叫做状态模块
#state 模块可以执行 salt 的 sls 文件
#sls 之 salt 脚本的编写与使用
1. 更改配置文件，添加如下参数，注意 yaml 的语法（修改了文件要重启 salt 服务）
vim /etc/salt/master
file_roots:
base:
- /srv/salt/base
dev:
- /srv/salt/dev
test:
- /srv/salt/test/
创建文件夹
mkdir -p /srv/salt/{base,dev,test}
2. 重启所有的 salt 服务
systemctl restart salt-master
systemctl restart salt-mion
#注意重启了服务，秘钥需要再次接受

3. 编写 nginx.sls 文件，放在 /srv/salt/base 底下，（注意，nginx.sls 文件，需要在所有机器上都有）
salt-cp "*" /srv/salt/base/nginx.sls /srv/salt/base/ #将 master 机器上的 nginx.sls，批量分发到所有节点上

4. 调用 state 模块，执行 nginx.sls 文件

salt "*" state.sls nginx #执行命令

#saltstack 两大数据管理中心 grains(静态采集数据) 与 pillar（动态采集数据）
#

salt "*" grains.items #采集所有 minion 机器的硬件信息，返回字典数据，key 和 value
salt "*" grains.item osfullname #通过 item 方法，通过 key，返回单独的 value
salt "*" grains.item ipv4
salt "*" grains.item ipv4 os hostname #支持多 key 的方式查看信息

#通过 -G 参数，指明是 grains 模块，匹配到所有的 操作系统是 7 系列的机器，然后执行命令
salt -G 'osrelease:7*' cmd.run "echo'i am from master....'> /tmp/salt.txt"

#自定义设置 granis 数据
salt "*" grains.setval my_class s14

#删除自定义 grains 的值
salt "*" grains.delval my_class

#如果想永久删除这个 key，需要删除 minion 底下的 /etc/salt/grains 文件

设置 key value 的操作 是调用 __setitems__
del __del__
__str__
__len__

ubuntu 安装 pycharm
1.windows 下打开 cmd
1.cd 到 pycharm 存放路径
2.python -m http.server
3.IP 地址
ipconfig
4. 浏览器访问
192.168.12.14:8000
2.ubunban 中浏览器访问
192.168.12.14:8000
3. 下载 pycharm 包
4. 解压缩 pycharm 的 linux 软件包
tar -zxvf pycharm-community-2018.2.4.tar.gz
cd pycharm-community-2018.2.4
cd bin
./pycharm.sh
5. 下载 vim
apt-get install vim
6. 在桌面添加一个普通文本名为 Pycharm.desktop，写入如下信息
[Desktop Entry]
Version=1.0
Type=Application
Name=Pycharm
#找到 pycharm 的图标
Icon=/opt/pycharm-community-2018.2.4/bin/pycharm.png
#找到 pycharm 的应用程序
Exec=/opt/pycharm-community-2018.2.4/bin/pycharm.sh

MimeType=application/x-py;

Name[en_US]=pycharm

6. 右击 Pycharm.desktop 这个文件，设置属性，为可执行