Linux
day01
测试工程师（小姑娘），找出程序bug的人，和开发相爱相杀
-
找出一个bug，+100元，开发-100元
-
功能测试，页面点点点
-
自动化测试，测试技能+python脚本
-
运维工程师，背锅侠，服务器有任何问题，找运维
- 运维开发，linux技能+python开发，写一个运维平台（CMDB管理服务器资产的平台）
-
UI设计（小姐姐）
-
安全，系统安全，网络安全
-
实施工程师，技术支持的，（suse德国linux系统，人天服务，8k/月打折，浦发银行，上海交行，移动，电信，一个运维去现场维护一天，9k/天）
-
前端小姐姐(nodejs 服务端开发)
-
DBA，数据库管理员，专业维护mysql，oracle的
-
后端开发大神（python开发）
- Crm 后台开发 ,面向的用户是什么样的群体？,企业内部，面对员工的（管理员工数据的平台）
-
爬虫开发（python）
-
IDC运维（专门在机房，照顾服务器的）
-
helpdesk(桌面运维，专业维护公司IT资产，打印机，笔记本维修，重装系统，装驱动)
对于初创型的小公司，陌陌公司刚起步，交友，用户量很少，网站并发数也很低
开发架构不能太复杂，必须招来一个专业的运维，并且可能会影响开发进度，开发难度
选择网站的黄金架构LNMP
（Linux+Nginx+Mysql+PHP/Perl/Python）
Linux运维人员的核心职责
-
网站数据不能丢，学习mysql的主从复制，MHA高可用容灾技术
- Redis（缓存性数据库，新浪的微博评论，点赞，都存储在redis中）
- redis内存性数据库，断电丢失，重启进程数据丢失
- redis的主从复制（一主一备用服务器）
- redis数据持久化来做(将内存数据库写入到磁盘上)
- redis哨兵（等待后续揭晓..）
-
网站7*24小时运转
- 搭建监控系统，开发监控平台
- 出了问题，立即打电话，发邮件，发微信，告诉运维，起来修电脑！
-
提升用户体验，访问速度要快
- 运维对于网站架构的优化
windows,mysql(突然嗝屁)
Linux就是一个操作系统而已
centos系统，您真硬核呀...
ubunt系统
你又一个window电脑，让你再安装一个操作系统去学习，你会用什么安装方案？
-
虚拟机（非常好用）
- 双系统（windows+linxu）
- 干掉windows，单独安装linux（支持图形化）
1.买一台硬件服务器，必须得有一个机器
（开发你得考虑，程序在机器上运行，消耗的内存，cpu等资源，IO吞吐量是否正常）
2.在这个机器上安装操作系统
告诉我，你的笔记本外观有什么？
- 屏幕，显示屏，输出设备
- 键盘，输入设备，用于数据输入的
- 触摸板，输入设备
- 各种借口，电源接口，USB借口
- touch bar，使用的mac触摸屏
- 光驱，安装操作系统，读取DVD资料的
- 摄像头
- 音箱
笔记本的内部有什么？（对于系统速度的提升，优化都是扯淡，花钱就能解决所有的问题，先从硬件角度考虑）
- 硬盘，数据存储的，（SATA类型的机械硬盘，和SSD固态硬盘，对于数据的IO，哪个快？SSD胜出）
- 主板，将各种硬件设备，组装在一起的，以及BIOS主板系统的安装
- 内存条
一个纯python后台的应用，odoo，写的一平台，性能测试预计有5W的并发
由于新业务来到，并发超过5W了，后台吃撑不住了，出现大量的500报错
单纯的用uwsgi+odoo，运行的后台
-
在网站前面挂一个中间层，nginx（负载均衡，动静态请求分发，支持大并发的一个软件）
-
服务器内存使用量以及达到 80%以上
-
扩大服务器内存16*2=32GB ，网站处理后台，立马正常了
-
为什么资源消耗这么多？
-
内存泄漏，with open 自动关闭文件句柄 ，释放内存
-
用户请求- > 后台 -> 人脸识别登录功能，数据发给了百度的API -> 后台响应，识别是否通过
-
照片数据放在一个变量当中
-
在代码的结尾，没有人在使用这个变量了，
-
pic=' ' 将变量等于了一个空字符串 ，内存泄漏立马被解决了，照片数据被python自动gc回收了
-
-
常见的状态码，status code有哪些
- 404 40x系列，客户端的请求报错，请求的url可能不存在，或者过期了
- 302 30x系列，客户端的请求重定向，www.pythonav.cn 更换域名了，跳转到新域名www.pythonav.com
- 浏览器的URL是会发生变化的
- 503 50x 系列，指的是服务端代码出错，服务端处理请求出问题了
- 200 20x系列，请求正确的被响应了
- 100 100x
服务器
服务器是在网络中对外提供服务的，一个超强性能的计算机（更稳定，更安全，安装linux系统）
区别在于数据的安全性。
云计算的概念
1.你们家中所用的水资源、电力资源，煤气资源，从哪来的?
我们百姓都是花钱，从水厂，电厂，煤气厂，按量购买的资源
水厂、电厂等，将所有的水利资源，电力资源，集中到了一起，进行按量贩卖
计算机角度：
阿里，腾讯，华为等公司，购买了大量的实体服务器，组成了一个超大的计算机资源池，然后按量贩卖
在阿里云的后台，50元/月 购买 1G1核 50G磁盘的服务器
对于初创型公司（路飞学城）：
8台阿里云
本金比较少，购买云服务器即可，（数据并不安全，你的数据都掌握在别人的手里）
对于中等规模公司，马蜂窝，知乎等：
购买自己的硬件服务器（服务器价格也不低），需要运行在零度、无尘、无湿度的一个环境（防止服务器发热，防止短路，静电）
中等公司会把自己的服务器，托管在一个专业的机房中心（世纪互联，有自己的园区，专门打造服务器运行环境的）外面的公司，就得花钱租赁机器托管的位置
大型公司，BAT，苹果公司，特别有钱
云上贵州，买了一块地，打造了一个数据中心(苹果公司的服务器都在这了)
uptime命令 ，检查服务器运行了多久 ，3700 days
一个公司的技术栈架构
外企，500强的外企
收费版的技术栈：
java + oralce + jquery + svn + mencached + redhat(收费版的linux，考rhce rhca资格证书)
省钱的技术栈，开源的技术栈:
java + python + jquery + git + redis + centos (免费版的redhat)
服务器环境是
dell 28台硬件服务器，dell poweredger R720型号
通过vmware esxi虚拟化技术，创建出了260+个数的linux系统
windows + vmware workstation(个人学习版，性能较弱，N多个虚拟机)
云服务器(阿里云，腾讯云)
自然灾害，云服务器
物理服务器（自己购买一台实体的计算机，安装linux系统）
机房托管
服务器是按照厚度收管理费的，机器厚度 以U为单位
知道什么是服务器之后，就得开始学习什么是Linux了
走进Linux的大门
机器就是一堆冷冰冰的硬件
需要安装操作系统之后，才有灵魂
python操作linux的模块是什么？
os模块
subprocess
shell壳的作用
老王学习python，在cmd里面写入了一段代码 print("隔壁的小孩长得越来越像我...")
↓
交给python翻译官
解释成机器码
↓
机器认识这一段话的作用，开始执行，然后 输出给用户
用户在命令行敲下 ls cd mkdir 这些linux的命令，计算机也是不认识的
↓
shell(linux下的bash脚本语言的解释器，翻译官)
↓
翻译给机器，去执行
开源的意义
闭源的缺点
1.危险性
王小贝开发出了一个crm系统，收费的闭源软件，卖给我用，50元/月
长久的人天服务，持续的要对这个项目进行优化
小贝在源码中嵌入了time.sleep(2.8)
可能在源码中，嵌入恶意代码，远程发送给他自己的机器
2.如果小贝突然不做程序了 ，crm没人可维护了，我是不是可能会造成重大损失。。
开源特点
1.透明性 ，你在github下载django源代码 ，全世界那么多人都在用，能够发现更多的问题
2.开源程序，是由诸多程序员共同维护
3.程序的优质性更高
Linus 是坐着的姓名，这人不单开发了操作系统，git也是他开发的
linux 是系统的名字
linux发行版介绍
发行版是什么意思？
手机，就是一个名词
各个厂家，针对手机做了定制，开发出了 华为手机，苹果手机，oppo手机
linux也是一个操作系统的吗名词，
各家公司针对linux源码做了一些定时，开发出了不同版本的linux系统
1.redhat红帽子系统，收费，全世界用的最多的系统
2.centos,全世界用的第二多的服务端操作系统，和redhat用法一模一样，名字不一样而已，免费
3.ubuntu用在个人电脑，开发环境使用，以及物联网领域
4.suse，德国linux，数据安全性很强
学习安装linux系统
1.准备好vmware软件，根据博客，或是视频学习安装流程
【网络连接方式】
桥接 ，好比所有人都在25期教室，公用这个教室的局域网段 192.168.11.0~192.168.11.255
教室内有60个同学，插上了网线，所有人都是 192.168.11.x 系列的ip，自动分配一个
虚拟机选择桥接之后，就好比教室又来了一个同学，插上线了网线，公用宿主机网段的ip
60个人都装了一个虚拟机，用的是桥接 60*3 =180 个
都选择桥接，可能会遇见什么问题，就是ip不够用了，可能会造成ip冲突
虚拟机选择桥接，可以在局域网内的其他同学通信
【NAT】
网络地址转换，基于你宿主机的网卡，在机器内部生成一个私有的局域网
虚拟机选择NAT的话，只能和自己的私有局域网段通信了，以及和宿主机通信，和教室内的其他同学，就无法通信了
【仅主机模式】
单机模式，虚拟机只能和宿主机通信，没什么用
图形化软件界面
图形化是linux安装了名为 gnonne的软件
进入到linux界面后，可以输入 ifconfig命令查看网络ip地址
1.登录系统后，需要切换root超级用户，否则权限很低
su - root #需要输入root密码
如果不能用，输入，
yum install net-tools -y #安装软件包 net-tools
2.此时你应该就可以输入ifconfig命令了
切换图形化和纯黑屏的命令
ctrl + alt + f1~f7 代表linux默认的7个终端
f1 是图形化 其他是纯黑屏
这些我们几乎用不上，我们都是用远程连接的方式操作
远程连接linux
对于服务器而言，我们不会直接去触碰机器，而是通过网络连接
1.确保你的服务器，正确的获取到了ip地址
ifconfig #查看到讲师的机器ip是 192.168.178.134
2.安装远程连接工具
windows点的同学，安装xshell 或者 secureCRT 或者
这2个软件其实也就是封装了 ssh命令而已
用macos的同学，直接使用ssh命令即可
ssh root@192.168.178.134
ip地址，标识了计算机在网络中的地址信息
123.206.16.61 这是一个公网的ip地址段，全世界都可以访问的
192.168.178.134 这是一个局域网的地址段，只有局域网内可以访问
127.0.0.1 ，本地回环地址，用于测试机器内部间通信的一个ip，只能自己和自己玩的地址
django程序启动在 127.0.0.1:8000
0.0.0.0 这个地址，表示注册绑定一台机器，所有的ip地址
由于一台服务器可能存在多个网卡，比如
linux机器 的2个ip
网卡1：192.168.178.134
网卡2：193.168.178.140
此时我启动django， python3 manage.py runserver
默认启动在 127.0.0.1:8000 windows机器能访问到吗？ 答案是不能
那我启动在 python3 manage.py runserver 192.168.178.134:8000
windows怎么访问？直接访问192.168.178.134:8000地址即可
这样启动，192.168.178.140用户就无法访问到django了
所以在服务器上启动项目，一般都直接使用0.0.0.0地址，能够同时注册在
网卡1：192.168.178.134
网卡2：193.168.178.140
这2个ip上，
如此启动python3 manage.py runserver 0.0.0.0:8000
用户访问 192.168.178.134:8000
或者
193.168.178.140:8000 都可以了
port端口的概念，常见端口是？
一个端口对应一个服务
8080 ------自定义用的端口
3306--- mysql默认端口
80 --- http默认端口
443 ---https默认端口
6379 --- redis默认端口
22 ----- 用于远程连接服务器用的端口 22
服务器端口 ----------银行的窗口
银行的 1号窗口---取钱
2号窗口----办理贷款
3号窗口---存款
linux命令提示符
linux命令语法如下
[root@bogon ~]# ls /tmp #这个命令表示，我要查看 /tmp 这个目录下的内容
#第二个简单的命令
#rm 命令 -f 参数（强制性删除） /tmp/oldboy.txt
rm -f /tmp/oldboy.txt
简单的命令 敲打
[root@bogon ~]# cd /home #目录切换，切换到 /home文件夹下
[root@bogon home]#pwd #我在哪 ，能够输出当前所在的绝对路径
[root@bogon home]# pwd
/home
[root@bogon home]# whoami #我是谁
root
[root@bogon pyyu]# pwd
/home/pyyu #linux的路径写法，如此
linux的文件系统 目录结构
windows的目录
windows的目录结构，是反斜杠的目录分隔符
是
C:\
D:\
E:\
这种多个盘符的形式，可能存在多个目录顶点
linux的目录
只有一个 根目录
/
例如
/home # 根目录下有一个home文件夹
/s25 #根目录下有一个s25文件夹
#根目录下有2个同级的文件夹，男同学和女同学
/s25/男同学/小明.txt
/s25/女同学
文件目录增删改查操作
linux命令的语法
命令 可选参数 你要操作的对象
修改linux支持文件的命令
export LC_ALL=zh_CN.UTF-8 #设置linux一个全局的中文变量
增
1.创建一个普通文本文件 语法是 touch 文件名
[root@bogon tmp]# touch music.txt
2.创建一个隐藏的文件，创建一个隐藏的 singer.txt
touch .singer.txt #创建隐藏文件
3.创建一个文件夹，名字叫做s25
[root@bogon tmp]# mkdir s25
4.创建一个递归的文件夹，如 /s25/男同学 /s25/女同学
mkdir -p /s25/男同学 /s25/女同学 # -p参数是 创建文件夹及其父文件夹
5.创建一个递归的文件夹 ，如 /s25new/男同学 /s25new/女同学
mkdir -p /s25new/{男同学,女同学} #创建一个/s25文件夹，且创建2个平级的文件夹
删
rm命令，是remove的缩写，删除文件或是文件夹
#语法是
rm 文件/文件夹 #删除文件/文件夹
比如
rm test.txt #删除文件，默认有让用户确认删除的提示
rm -f test.txt #强制删除文件，不需要提示确认
rm -r 文件夹名 #递归删除文件夹，及其内部的文件
#提问，如何强制性删除 文件夹 ，以及其内部的资料
#这是一个危险的命令！！！！请理解后慎用！！！
#这是一个危险的命令！！！！请理解后慎用！！！
#这是一个危险的命令！！！！请理解后慎用！！！
rm -rf /* #叫做删库到跑路，准备被打死吧。。。。万万不得敲。。。。
rm -rf /* #叫做删库到跑路，准备被打死吧。。。。万万不得敲。。。。
rm -rf ./* #强制性删除当前目录下的所有内容
改
cd /home #切换到 /home目录下
ls . #查看相对的home目录下有什么内容
查
#查询当前目录下的内容 ls命令
ls命令，就是list的缩写
[root@bogon /]# ls .
bin dev home lib64 mnt proc run srv tmp var
boot etc lib media opt root sbin sys usr
#查看文件夹中所有内容，以及隐藏的文件，在linux下，以.开头的文件，是隐藏的，默认直接看不到
[root@bogon tmp]# ls -a firefox_pyyu/
几个特殊的目录
. 代表当前的目录
.. 代表上一级的目录 #比如 cd .. 进入上一级目录
~ 代表当前登录用户的家目录，root用户就是/root pyyu用户就是 /home/pyyu
- 代表上一次的工作目录
绝对路径，相对路径
绝对路径：只要是从根目录开始的写法，就是绝对路径
相对路径：非从根目录开始的写法，就是相对路径
#在/home目录下创建 s25文件夹，绝对，相对路径的写法
1.相对路径，以你当前的位置为相对，创建
比如我此时在 /tmp目录下，我的上一级就是 / ，因此可以这么写
[root@bogon tmp]# mkdir ../home/s25
2.绝对路径的写法，一般是绝不会错的，无需考虑你当前所在的位置，直接敲绝对路径即可
mkdir /home/s25
day02
每日上课前的操作
1.打开vmware workstation软件
2.开启centos虚拟机，查看动态ip地址（今日分配到的ip地址）
今日ip：192.168.178.134
3.使用xshell远程连接上 centos系统
ssh root@192.168.178.134
4.准备开始学习新命令操作
如果开机没有ip怎么办
获取ip的步骤 如下
1.vim编辑网卡配置文件，修改如下参数
[root@s25linux tmp]# cd /etc/sysconfig/network-scripts/
vim修改此文件，找到如下参数，改为yes
ONBOOT="yes"
2.确保vmware 正确选择了 桥接 或是NAT，且已经连接上了
3. 命令重启网络设置
systemctl stop NetworkManager #关闭无线网络服务
systemctl restart network #重启有线网服务
#这2个命令执行都没有任何提示，表示正确的重启了网络配置
4.此时查看ip地址是否存在了
ip addr show
Linux常用命令
mkdir
mkdir 感谢老铁的花花 感谢老铁送上的飞机
mkdir -p 斗鱼/lol 虎牙/王者农药
tree
树的意思，以树状图显示文件目录的层级结构
#确保你的机器可以上网 ，yum如同pip一样，自动的安装东西，解决依赖
# pip 是给python安装模块的工具
# yum 是给linux安装系统软件的工具
yum install tree -y # -y默认yes同意安装
[root@s25linux tmp]# mkdir -p a/b c/d
[root@s25linux tmp]# tree
查看linux命令的帮助信息
1.用man手册，linux提供的帮助文档
man ls
man cp
man mkdir
2.命令加上 --help参数，查看简短帮助信息
mkdir --help
rm --help
3.在线的搜索一些命令查询网站
http://linux.51yip.com/
4.在线询问人工智能---超哥
...
echo命令
echo命令如同python的print一样，能够输出字符串到屏幕给用户看
案例
[root@s25linux tmp]# echo "感谢老铁送上的奥力给"
感谢老铁送上的奥力给
#linux在命令行的变量赋值，是临时生效的
#输出变量的值
#定义变量，中间有空格
name="感谢老铁送上的飞机"
#输出变量的值
[root@s25linux tmp]# echo $name
感谢老铁送上的飞机
PATH变量
PATH就是定义一些常用的软件可执行命令的目录，放入系统中，可以快捷的查询，而不需要每次都输入绝对路径
1.为什么系统能够直接找到python解释器？
[root@s25linux tmp]# which python #输出命令所在的绝对路径
/bin/python
2.学习linux的PATH，
[root@s25linux tmp]# echo $PATH
/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin
注意，PATH的路径，是有先后顺序的，从左往右，读取的
3.如果编译安装了一个python3，装在了 /opt/python36/目录下，怎么添加PATH？
#这个变量赋值的代码，就是添加python3到环境变量中了
PATH="/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:"
4.由于上述变量赋值的操作，只是临时生效，我们想永久的更改PATH的值，还得修改/etc/profile
vim /etc/profile #打开文件，在文件末尾，添加PATH值的修改
PATH="/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:"
修改linux的全局配置文件
1.名字叫做 /etc/profile，里面是shell脚本语言
2.编辑这个文件，写入你想永久生效的变量和值，系统每次开机都会读取这个文件，让其生效
vim /etc/profile
写入如下内容
###这是自定义的变量，每次开机都能够读取了，第一条是设置系统中文的变量
export LC_ALL=zh_CN.UTF-8 #打开注释，系统支持中文
#export LC_ALL=en_US.UTF-8 #打开注释，系统就支持英文了
linux单引号和双引号的区别
单引号中的内容，仅仅就是个字符串了，不识别任何其他的特殊符号
双引号中的内容，能够识别特殊符号，以及变量
[root@s25linux ~]# echo '$name'
$name
[root@s25linux ~]# echo "$name"
我们是穿越在银河的火箭队
vim编辑器的用法
最基本的编辑器
windows
- 记事本
- sublime
- notapad++
- ....
linux
- vi 等同于记事本，很难用，没有语法颜色提示灯
- vim，等同于Notepad++,有颜色高亮，支持安装第三方插件，语法补全等等高级编辑器
vim使用流程
1. vim 需要单独安装的
yum instal vim -y # 安装
2.vim打开一个不存在的文件，默认会创建此文件
#用vim写一个python脚本，
#vim的使用流程
第一步：vim first.py ，此时会进入命令模式，按下字母 i，进入编辑模式
第二步：想要退出编辑模式，按下键盘的esc，回到命令模式
第三部：此时输入 shfit+冒号，输入一个英文的冒号，进入底线命令模式
第四步：输入 :wq! ，write写入内容，quit退出vim ！ 强制性的操作
:wq! 强制保存写入退出vim
:q! 强制不保存内容，直接退出
3.此时可以查看一下文件内容
[root@s25linux tmp]# cat first.py
#!coding:utf-8
print ("你看这个灯，它又大又量")
4.如何执行这个脚本？
python fisr.py #即可执行脚本文件了
cat命令
cat 猫，用这个只猫瞄一眼 文件的内容
cat 文件名
[root@s25linux tmp]# cat first.py
print ("你看这个灯，它又大又量")
#读取内容，且显示行号
cat -n 文件名
#利用cat写入文件内容，写一首诗
[root@s25linux tmp]# cat >> second.py << EOF
> #!coding:utf-8
> print("爱的魔力转圈圈")
> EOF
[root@s25linux tmp]#
[root@s25linux tmp]#
[root@s25linux tmp]#
[root@s25linux tmp]#
[root@s25linux tmp]# cat second.py
#!coding:utf-8
print("爱的魔力转圈圈")
linux的重定向符号
> #重定向输出覆盖符 ，如同 python的 with open 中的 w模式
>> #重定向输出 追加符 ，如同 a模式
< #重定向写入覆盖符，用的很少，用在数据导入等操作中,mysql数据导入
<< #用在cat命令中，很少见
案例
1.echo输出一个字符串，内容不在屏幕上打印，写入到一个文件中
[root@s25linux tmp]# echo "左手跟我一起画个龙" > 迪斯科.txt
[root@s25linux tmp]# echo "左手跟我一起画个龙" > 迪斯科.txt
[root@s25linux tmp]# echo "左手跟我一起画个龙" > 迪斯科.txt
[root@s25linux tmp]# echo "左手跟我一起画个龙" > 迪斯科.txt
[root@s25linux tmp]# echo "左手跟我一起画个龙" > 迪斯科.txt
[root@s25linux tmp]#
[root@s25linux tmp]#
[root@s25linux tmp]# cat -n 迪斯科.txt
1 左手跟我一起画个龙
2.追加写入文件内容
[root@s25linux tmp]# echo "右手和我划一道彩虹" >> 迪斯科.txt
cp命令
拷贝
#对于配置文件的修改，或者是代码文件的修改，防止突然写错了，复制一份
#复制文件
[root@s25linux tmp]# cp 木兰诗.txt 新_木兰诗.txt
#复制文件夹，复制文件夹需要添加 -r 递归复制参数
[root@s25linux tmp]# cp -r a new_a
mv命令
mv命令可以 移动文件 ，文件夹的路径
mv命令也能够进行 重命名
1.重命名的功能
语法是
mv 旧文件名 新文件名
[root@s25linux tmp]# mv 木兰诗.txt new_木兰诗.txt
2.移动位置
语法
mv 你要移动的文件或是文件夹 移动之后的目录名(如果文件夹存在，则移动，不存在是改名)
案例
mv test.txt b #移动 test.txt文件 到 b文件夹下（b文件夹得存在）
alias别名命令
为什么rm命令默认会有一个让用户确认删除的动作呢？
解答是因为 rm 的-i参数作用
alias #直接输入可以查看当前系统的别名
案例
1.给系统添加一个别名
当你敲下start就是在执行后面的长串命令，很方便
alias start="python3 /home/mysite/manager.py runserver 0.0.0.0:8000"
find命令
可以用于搜索机器上所有的资料，按照文件名字搜索，linux一切皆文件
语法
find 你要从哪找 -type 你要的文件类型是什么 -size 你要的文件内容多大 -name 你要的内容名字是什么
-type f 是找普通文本文件
-type d 是找 文件夹 类型
-name 是指定文件的名字内容
#在系统上 全局搜索，所有的.txt文件
find / -name "*.txt"
#指定在etc目录下，进行局部搜索，一个网卡配置文件，网卡名字是以ifcfg开头的 ，文本类型文件
find /etc -type f -name "ifcfg*"
案例2
1.准备好测试的数据，在/tmp目录下
mkdir /tmp/python{1..5} #在/tmp目录下 创建 出 python1 ptyhon2 ... python5
touch /tmp/python_{a..d} #在/tmp目录下创建出 python_a ptyhon_b .. python_d 几个文件
2.查看准备好的测试文件
[root@s25linux tmp]# ls
python1 python3 python5 python_b python_d
python2 python4 python_a python_c
3.在/tmp目录下联系find命令
4.找出/tmp目录下所有的pyton相关内容
[root@s25linux tmp]# find . -name "python*"
./python1
./python2
./python3
./python4
./python5
./python_a
./python_b
./python_c
./python_d
5.找出/tmp 下所有的python相关的文件
[root@s25linux tmp]# find . -type f -name "python*"
./python_a
./python_b
./python_c
./python_d
6.反之找出所有的文件夹
find . -type d -name "python*"
7.全局搜索，超过10M大小的 txt文本
[root@s25linux tmp]# find / -size +10M -name "*.txt"
/tmp/python2.txt
/tmp/python3.txt
查看文件，文件夹大小
ls -lh # -h参数，是显示文件单位，以kb mb gb大小为单位 -l是列表形式，列出文件夹中详细信息
linux的管道符命令
1.例如过滤服务器上的进程信息
2.例如过滤服务器上的端口状态信息
grep命令
grep是linux强大的三剑客之一，从文本中，过滤有用信息的命令
1.语法
grep "你想过滤的字符串" 需要过滤的文件 #用法一
准备一个测试的文件test.txt
[root@s25linux tmp]# cat test.txt
跟着我左右右手一个慢动作
#左右右手慢动作重播
一个大西瓜，送给你，也不送给他
ALLOW_HOSTS=[]
2.过滤文件中的相关内容
#找出文件中含有 "大" 字的行，且显示此内容，在哪一行
grep -n "大" test.txt # -n 参数是显示行号
#忽略大小写，找出ALLOW_HOSTS=[]参数是否被修改
grep -i "al" test.txt
#过滤出此文件非空白行，如何操作？
拆解如下
找出所有的空白行
[root@s25linux tmp]# grep "^$" test.txt # "^$" 以空开头，以空结尾，因此是空白行
# -v 参数是 翻转过滤结果 ，找出 空白行以外的内容
[root@s25linux tmp]# grep -v "^$" test.txt
#过滤掉注释行，和空白行 ，如何操作？
[root@s25linux tmp]# grep -v "^#" test.txt | grep -v "^$"
跟着我左右右手一个慢动作
一个大西瓜，送给你，也不送给他
ALLOW_HOSTS=[]
案例2
cat 文件 | grep "你想要的内容" #用法二
1.找出linux的用户信息文件，中 有关pyyu的行信息 /etc/passwd
cat
[root@s25linux tmp]# cat /etc/passwd | grep "pyyu"
pyyu:x:1000:1000:pyyu:/home/pyyu:/bin/bash
head、tail命令
head和tail都是能够读取文件内容的
语法是
head 文件名 #默认从文件的前10行看
head /etc/passwd #默认看前10行
head -3 /etc/passwd #查看文件的前3行
tail 文件名 #默认从文件的后10行看
tail -2 /etc/passwd #查看文件的后2行
tail命令的 实时监控用法 ，可以用于检测线上的日志文件，检测用户的请求信息
tail -f 文件名 #实时刷新文件内容
tail -f /tmp/test.txt #能够检测文件内容的变化
如何查看文件的，中间20行-30行的内容，今天的作业练习
scp命令
在2台linux机器(macos)之间，通过网络安全的传输文件，文件夹
scp命令 语法是
环境准备，准备2台linux机器
确保两台机器能够通信
机器1：192.168.178.134
机器2：192.168.178.235
案例1：
我登录的是 机器1
需求1：将机器1的/tmp/好嗨哦.txt 发送到 机器2的/tmp目录下
[root@s25linux tmp]# scp /tmp/好嗨哦.txt root@192.168.178.235:/tmp/
需求2：把机器2的/tmp目录下的资料 给拿到本地的/opt目录下
scp 你想要的内容 内容发送到哪里
scp root@192.168.178.235:/tmp/小样别偷看.txt /opt/
情况2，我登录的是 机器2
【把别人的资料拿来】
案例1：我想拿到机器1的/opt/test.txt 拿到机器2的/tmp目录下
scp 我想要的内容 内容存放的地点
scp root@192.168.178.134:/opt/test.txt /tmp/
【把自己的资料发给别人】
案例2：我想把本地的/home/fisrst.py 发送给机器1的/home目录下
scp /home/first.py 账号@机器1:/home/
scp /home/first.py root@192.168.178.134:/home/
#如果发送的是整个文件夹，就得加上 -r 递归的拷贝参数
[root@s25linux tmp]# scp -r ./lol root@192.168.178.235:/tmp/
#用通配符发送多个文件
[root@s25linux tmp]# scp -r ./* root@192.168.178.235:/tmp/134bak/
lrzsz工具
用于windows(基于xshell工具)和linux之间互相传递文件
1.安装此工具
yum install lrzsz -y
2.安装好lrzsz之后，就存在了2个命令 一个是 rz 一个是sz
rz #直接输入rz命令，能够蹦出一个弹窗，接收windows的资料
sz 文件 #发送linux的一个文件，发给 windows某个位置，也是出现一个弹窗
du命令
用法
du 【参数】【文件或目录】
-s 显示总计
-h 以k，M,G为单位显示，可读性强
案例
统计/var/log/文件夹大小
du -sh /var/log/
#显示当前目录下 所有文件的大小
[root@s25linux tmp]# du -h ./*
vim命令的用法
1. vim 文件名 # 此时进入命令模式，你敲击键盘的动作都会被识别是一个vim的命令 ，比如 a,i,o 进入插入模式
2.但凡进入插入模式之后，敲击键盘的动作就会被识别为是 普通的字符串了
3.按下esc退出编辑模式之后，又进入命令模式了
4.输入 :wq! 保存vim的写入内容，然后退出vim，结束操作
在命令模式下，常用的指令
$ 快速移动到行尾
0 快速移动到光标的行首
x 删除光标所在的字符
gg 移动到文件的第一行
G 移动到文件的最后一行
/string 你要从文件开头寻找的内容，例如 /to 找出文件中所有的to字符，按下n键，跳转到下一个匹配的字符
?string 从文件的第行，向上搜索字符串信息
% 找到括号的另一半
yy 复制光标当前行
3yy 复制光标后3行
p 打印yy所复制的内容
dd 删除光标所在行
4dd 删除光标向下的4行内容
dG 删除光标当前行，到行尾的所有内容
u 就是撤销上一次的动作
如何快速的复制，打印生成多行内容
例如 按下 9999yy 就是 复制 9999行，然后按下p打印，就能够快速的复制N多行了...
底线命令模式下
:wq!
:q! 不保存退出
:数字 快速的定位到某一行
:set nu 显示vim的行号
top命令
windows的任务管理器见过吧
能够显示 动态的进程信息
cpu、内存，网络，磁盘io等使用情况 ，也就是一个资源管理器
那么linux的资源管理器 就是top命令
第一行 (uptime)
系统时间 主机运行时间 用户连接数(who) 系统1，5，15分钟的平均负载
第二行:进程信息
进程总数 正在运行的进程数 睡眠的进程数 停止的进程数 僵尸进程数
第三行:cpu信息
1.5 us：用户空间所占CPU百分比
0.9 sy：内核空间占用CPU百分比
0.0 ni：用户进程空间内改变过优先级的进程占用CPU百分比
97.5 id：空闲CPU百分比
0.2 wa：等待输入输出的CPU时间百分比
0.0 hi：硬件CPU中断占用百分比
0.0 si：软中断占用百分比
0.0 st：虚拟机占用百分比
第四行：内存信息（与第五行的信息类似与free命令）
total：物理内存总量
used：已使用的内存总量
free：空闲的内存总量（free+used=total）
buffers：用作内核缓存的内存量
第五行：swap信息
total：交换分区总量
used：已使用的交换分区总量
free：空闲交换区总量
cached Mem：缓冲的交换区总量，内存中的内容被换出到交换区，然后又被换入到内存，但是使用过的交换区没有被覆盖，交换区的这些内容已存在于内存中的交换区的大小，相应的内存再次被换出时可不必再对交换区写入。
ps命令
用于查看linux进程信息的命令
语法就是
ps -ef # -ef，是一个组合参数，-e -f 的缩写，默认显示linux所有的进程信息，以及pid，时间，进程名等信息
#过滤系统有关vim的进程
[root@s25linux ~]# ps -ef | grep "vim"
root 24277 7379 0 16:09 pts/1 00:00:00 vim ps是怎么用的.txt
1.一个django运行后，如何验证django是否运行了，它会产生些什么内容？
能够产生日志，检测到用户的请求，说明django运行了
查看端口情况，django会占用一个端口
产生一个python相关的进程信息
ps -
kill命令
杀死进程的命令
kill 进程的id号
如果遇见卡死的进程，杀不掉，就发送 -9 强制的信号
kill -9 pid
netstat命令
查看linux的网络端口情况
语法如下
常用的参数组合 -t -n -u -l -p
[root@s25linux tmp]# netstat -tunlp #显示机器所有的tcp、udp的所有端口连接情况
#例如验证服务器80端口是否存在
netstat -tunlp | grep 80
#过滤3306端口是否存在
netstat -tunlp |grep 3306
#过滤ssh服务是否正常
[root@s25linux tmp]# netstat -tunlp | grep ssh
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 1147/sshd
tcp6 0 0 :::22 :::* LISTEN 1147/sshd
#有些公司为了保护服务器安全，更改了默认的远程连接端口
# ssh端口 26674 ip 是 123.206.16.61 账号是 xiaohu 密码是 xiaohu666
#我怎么登陆服务器呢？用如下的命令去连接服务器
ssh -p 26674 xiaohu@123.206.16.61
ssh -p 22 root@192.168.178.134
root@192.168.178.134's password:
grep是支持正则表达式的
day03
1.打开vmware 虚拟机，通过ip addr show命令查看今日的ip地址
2.通过xshell远程连接linux机器，因为xshell远程终端更好用
Linux用户管理
对于一个qq群而言，有哪些角色划分，权利的划分
群主-----qq群里面，权利最大，想干嘛就干嘛，可以随意的拉人，踢人等等----相当于皇帝----相当于linux的root用户
管理员---他是root赋予的临时的超级权限-在用皇帝的身份狐假虎威---钦差大人---linux系统中的sudo命令--尚方宝剑
吃瓜群众---权利最低的，基本上只能够在自己的家目录，进行增删改查，其他目录，权限都很低-----linux的普通用户
系统创建了用户，同时会创建一个同名的组
例如
useradd caixukun #创建普通用户 caixukun，系统会在/etc/passwd文件中，增加一行用户信息
且同时创建了一个用户组 也叫caixukun ，存放在/etc/group 文件中
id命令
查看用户的账户信息的命令
例如
id root
[root@s25linux tmp]# id root
uid=0(root) gid=0(root) 组=0(root)
id caixukun
[root@s25linux tmp]# id caixukun
uid=1004(caixukun) gid=1004(caixukun) 组=1004(caixukun)
组的概念
对于技术部门，运维需要分配的单个用户的权限太散，太多，人太多了。。。
【权限控制，其实控制的就是，不同的组，不同用户，针对不同的文件夹，文件，操作的权限的不同】
比如说
mysql的默认数据存放路径，如 /var/lib/mysql/* 那么这个mysql的数据文件，以及所有的文件夹，是属于哪个组，哪个用户管理呢？
比如说有一个文件
-rw-r--r--. 1 root root 0 2月 17 08:52 mysql.log
前端组
后端组，权利稍微大一点。
运维组，对于服务器操作权限很大，可以使用root的权限
测试部门
安全部门
DB部门
运维都得对上述的人，进行权限控制，对于服务器的操作权限
因此引入组的概念，针对整个组管理，就方便多了，
root而言
root为什么叫root，是因为系统提出了UID的概念，用户id号，用户id为0的就是系统的超级用户
普通用户由root用户创建，默认的UID是从1000开始进行累计，权利很低
普通用户
默认用户家目录都在/home
例如
/home/pyyu/
/home/alex/
/home/wupeiqi/
用户管理的命令
添加删除用户，注意的是，涉及到权限的修改，只能用root去操作，其他人基本上没权限
useradd caixukun #创建用户caixukun
passwd caixukun #给用户修改密码，
userdel caixukun #删掉caixukun这个用户
userdel -rf caixukun #删除用户，且删除用户的家目录
用户登录切换
su - 用户名 #用户登录切换，普通用户切换，需要输入密码，root用户想干嘛都不需要密码
#这个减号必须加上，叫做，完全的环境变量切换，是正确的切换方式
比如
su - pyyu
su - root
尚方宝剑命令sudo
1.当pyyu用户，想要进入/root文件夹，发现权限不够，怎么办
思路：
1.使用sudo命令，默认以root身份去执行命令
例如 sudo cd /root
思路2：
把pyyu用户，加入到root组里，也就拥有了root组的权限，但是还是得查看这个group的权限
思路3：
直接修改/root文件夹的权限，允许其他人，也可以读写执行 ，其他人也就能够进入到/root文件夹了
【sudo命令使用配置流程】
1.使用visudo命令，修改配置文件，添加你允许执行sudo命令的用户
visudo #打开文件后，找到大约在91行的内容，修改为如下
91 ## Allow root to run any commands anywhere
92 root ALL=(ALL) ALL
93 pyyu ALL=(ALL) ALL
2.保存退出之后，即可使用sudo命令了
sudo ls /root
Linux文件、目录权限管理
文件管理的权限-----也就是针对这文件，属于哪个用户，属于哪个组，以及对应的权限是什么
背景：比如武沛奇，有一个手机 iphone7
这个iphone7 属于哪个用户？他的权限应该是怎样的？(他对于这个手机使用的权限)
(这个手机属于 武沛奇，并且他的权限，应该是 最大的权限，可以随意的把玩 )
对于武沛奇自己而言
是可以任意的把玩，用读写执行的权限
武沛奇可以看手机，改手机资料，手机给砸了
那武沛奇的家庭成员（他老婆），对于这个手机而言，属于什么样的关系？并且可能的权限是什么？
读，写，执行（可以看手机，改手机内容，以及砸掉手机）
他老婆属于武沛奇这个家庭组里，可能分配的权限是，读写权限（这个权限都是有权利最大的人分配的，好比一家之主说话才算话）
因此，武沛奇家庭组的人，可能只能读写，，也就是，可以 看手机 ，，玩手机，而不能砸掉
那此时，超哥来了，对于这个武沛奇的手机而言，属于什么身份关系？以及可能用的 读写执行权限是什么？？
超哥对于这个手机而言，就属于一个 其他人，没有任何的关系，因此权限一般很低，只能看一看，摸都不给摸
对于如上的比喻做一个总结
对于linux系统而言，文件、文件夹，都是有 user 属主， group属组的一个角色分配，还存在一个other其他人
这三个身份的划分
并且设定了 r w x 三个权利的限制，也就是 读，写，执行（对于文件的读写执行）
场景：
1. root用户在/tmp目录下 创建了一个 文件 叫做 root.txt ，因此这个文件默认就属于root用户，属于root用户组
2.此时 一个普通用户，登录了机器 ，如
ssh chaoge@192.168.178.134 登录机器之后，chaoge对于这个 root.txt文件而言，就是一个其他人的身份了
查看文件夹的详细信息
[root@s25linux ~]# ll /tmp
总用量 4
drwxr-xr-x. 2 root root 6 2月 17 11:00 hehe #文件夹
解读它的信息
drwxr-xr-x 拆分如下
d d代表是一个文件夹
rwx user是root，root可以读写执行
r-x group也是root，root组里的成员，可以读，执行
r-x others权限是 读，执行
#文件的权限，必须顺序是 rwx ，没有权限则写一个-号
-rw-r--r--. 1 pyyu pyyu 2328 2月 17 09:15 pwd.txt #文件
#解读如上的权限
- 开头是 -号，就是普通的文本类型
rw- user是pyyu，pyyu这个用户权限是 可读、可写，不可执行
r-- group是pyyu，只读
r-- 此时peiqi这个用户对于pwd.txt这个文件，权限就是 只读的
对于文件的rwx
r cat，more，less，head，等读取文件内容的操作
w vim ，echo，等写入内容的操作
x 可以执行的脚本，例如bash，python等脚本，文件会变成绿色
对于文件夹的rwx
r ls 查看文件夹内容
w 允许在文件夹中创建文件等操作
x 允许cd进入此文件夹
chmod命令总结
chmod 可以更改文件的权限，更改针对 user，group，other的权限修改，例如
chmod u+r file.txt #给文件的user，添加读的权限
chmod g-x file.txt #给文件的group组权限，去掉可执行
chmod o+r,o+w,o+x file.txt #给文件的other身份，最大的权限，读写执行
chmod 000 file.txt #给与文件最低的权限，任何人不得读写执行
chown
change owner缩写
更改文件的拥有者，user
chown 新的属主 file.txt
chgrp
更改文件的拥有组，group
change group 缩写
chgrp 新的属组 file.txt
软连接
windows的一个快捷方式而已
创建命令
ln -s 目标文件绝对路径 软连接绝对路径
[root@s25linux tmp]# ln -s /tmp/test.txt /opt/t.txt #给/tmp/test.txt创建一个快捷方式，放在/opt/t.txt 这里
删除快捷方式，删除软连接是不会影响源文件的
windows下装另一个qq在 D:\qq\qq.exe ，发送快捷方式到桌面
打包、压缩、解压缩
也就是linux的tar命令
打包，不节省空间
压缩，节省磁盘空间
语法
tar 命令
功能参数
-z 调用gzip命令，对文件压缩 ，加上这个参数，才会节省磁盘空间
-x 解包，拆快递
-v 显示整个过程
-f 必须写在参数结尾，指定压缩文件的名字
-c 打包，收拾快递
压缩文件的后缀，本没有意义，只是告诉别人，这个文件是用什么命令压缩/解压缩
*.gz gzip命令解压缩
*.tar 用tar命令解压缩
*.xz 用xz命令解压
*.zip 用unzip命令解压
案例1：打包/opt/目录下所有的内容，打包生成tar包allopt.tar
第一步：打包opt下所有内容
[root@s25linux opt]# tar -cvf allopt.tar ./*
第二步：解包这个tar包
[root@s25linux opt]# tar -xvf allopt.tar ./
案例2：打包，且压缩/opt目录下所有内容，生成tar.gz包allopt.tar.gz
第一步：打包，且压缩，就是加一个-z参数即可
[root@s25linux opt]# tar -zcvf allopt.tar.gz ./*
第二步：解压缩，常见的*.tar.gz，也有人会缩写成 *.tgz ，都可以如此的去解压缩
[root@s25linux opt]# tar -zxvf allopt.tar.gz ./
疑问：必须先打包再压缩吗？能对一个文件夹直接压缩吗？
解答： 打包，压缩是一体的，是调用tar命令，加上-z参数，自动就压缩了
tar -zcvf dir.tar.gz ./testdir/ #压缩此文件夹，放入到一个压缩文件 dir.tar.gz中
.gz是 压缩的常见后缀格式
防火墙
用于控制服务器的出/入流量
防止恶意流量攻击服务器，保护服务器的端口等服务。
在学习阶段是直接关闭的，专业的运维人员需要学习iptables软件的一些指令
云服务器，默认都有一个硬件防火墙，以及软件防火墙（iptables、firewalld）
我在服务器上，运行了django服务，如果开启了防火墙服务器，且没有自定义规则，默认是拒绝所有外来流量 ，导致我们windows无法访问到linux运行的django等程序
1.清空防火墙规则
iptables -F #清空防火墙规则
2.关闭防火墙的服务
systemctl stop firewalld #关闭防火墙服务
systemctl disable firewalld #禁止防火墙开机自启
DNS域名解析
什么是dns解析？
dns解析系统-------手机上的电话簿------- 小王----132xxx 小莉---186xxxx
dns服务器，存储了公网注册的所有（域名----ip）对应的解析关系
linux的dns客户端配置文件/etc/resolv.conf
里面定义了主备的两个dns服务器地址
[root@s25linux ~]# cat /etc/resolv.conf
# Generated by NetworkManager
#search localdomain
nameserver 119.29.29.29
nameserver 223.5.5.5
linux的本地dns强制解析文件 /etc/hosts，可以写入一些测试的域名，用于本地机器使用,域名解析优先级更高
[root@s25linux ~]# cat /etc/hosts
127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
127.0.0.1 pythonav.cn
nslookup命令
域名查找命令
nslookup www.pythonav.cn #寻找dns对应关系
浏览器输入url之后，是怎么解析的？发生了什么事？
浏览器里面输入 www.pythonav.com发生了什么
1.浏览器进行dns查找，解析 域名对应的ip机器，找到之后浏览器访问此ip地址
2.用户请求，发送到了服务器之后，优先是发给了nginx（web服务器），用户请求的是静态资源（jpg,html,css,jquery）nginx直接从磁盘上找到资料给与用户查看
如果nginx检测到用户请求是一个动态请求，登录，注册，读取数据库，例如 .php 例如 .aspx ，通过url匹配发现是动态请求，转发给后端的应用服务器（php,tomcat,django）
3.django处理完用户的动态请求之后，如果发现需要读取数据库，再通过pymysql向mysql读取数据
4.如果django处理请求，发现读取的是redis，再通过pyredis向redis拿数据
5.django处理完毕之后，返回给nginx
6.nginx返回给用户浏览器
7.浏览器渲染数据之后，给与用户查看页面
大型网站技术架构，很nb，好好看，面试可劲吹
crontab定时任务
crond定时任务服务，提供了一个客户端管理命令crontab
crontab -e #编辑定时任务配置文件
crontab -l #查看定时任务的规则
定时任务，注意的是 ，几号，和星期几不得共用
案例
1.每分钟，将一句话，追加写入到一个文件中
第一步：crontab -e #打开配置文件
写入如下内容，用的是vim编辑器命令
* * * * * /usr/bin/echo "有人问王思聪，钱是万能的吗？王思聪答：钱是万达的" >> /tmp/wsc.txt
2.检查定时任务
crontab -l
定时任务的语法规则
* * * * * 命令的绝对路径
分 时 日 月 周
3,5 * * * * #每小时的第3，第5分钟执行命令
15 2-5 * * * ￥每天的2点一刻，3点一刻，4点一刻，5点一刻，执行命令
每天8.30上班
30 08 * * * 去上班
每天12下班回家睡觉
00 00 * * * 回家睡觉
定时任务语法练习
#每分钟执行一次命令
* * * * * 命令的绝对路径
分 时 日 月 周
#每小时的3,15分钟执行命令
* * * * * 命令的绝对路径
分 时 日 月 周
3,15 * * * * 命令
#在上午8-11点的第3和第15分钟执行
* * * * * 命令的绝对路径
分 时 日 月 周
3,15 8-11 * * *
#每晚9:30执行命令
* * * * * 命令的绝对路径
分 时 日 月 周
30 21 * * *
#每周六、日的下午1：30执行命令
* * * * * 命令的绝对路径
分 时 日 月 周
30 13 * * 6,7
#每周一到周五的凌晨1点，清空/tmp目录的所有文件，注意执行的命令请用绝对路径，否则会执行失败
* * * * * 命令的绝对路径
分 时 日 月 周
0 1 * * 1-5 /usr/bin/rm -rf /tmp/*
#每晚的零点重启nginx
0 0 * * * /usr/bin/systemctl restart nginx
#每月的1,10,22日的4:45重启nginx
* * * * *
分 时 日 月 周
45 4 1,10,22 * * /usr/bin/systemctl restart nginx
#每个星期一的上午8点到11点的第3到15分钟执行命令
* * * * *
分 时 日 月 周
3-15 8-11 * * 1 命令绝对路径
记住一句话，服务器上操作，用绝对路径，基本不会出错了，除非手误，单词写错了。。。。
能用绝对路径，别用相对路径!
linux软件包管理
windows的软件管理，安装文件的后缀 *.exe
macos的应用程序安装 后缀 *.dmg
linux的二进制软件包 都是 *.rpm 格式的
软件的依赖关系
pip install flask #仅仅就安装了flask模块吗？肯定不是，会安装一堆依赖的模块，比如jinja2等模块
那么在linux平台，一个软件想要正确的运行，也得解决系统的开环库环境，解决依赖关系
linux平台的软件安装形式，有3个
- 源代码编译安装，此方式较为麻烦，但是可以自由选择软件的版本（因为是去官网下载最新版本代码），也可以扩展第三方额外的功能（五颗星）
- 扩展第三方功能
- 指定软件安装目录
- rpm包手动安装，此方式拒绝，需要手动解决依赖关系，贼恶心（两颗星）
- yum自动化安装软件，需要配置好yum源，能够自动搜索依赖关系，下载，安装，处理依赖关系（五颗星）
- 不好的地方在于，yum源仓库的软件，版本可能较低
- 无法指定安装路径，机器数量较多的时候，不容易控制
更换yum源
配置笔记
yum源的默认仓库文件夹是 /etc/yum.repos.d/，只有在这个目录第一层的*.repo结尾的文件，才会被yum读取
1.下载wget命令
yum install wget -y #wget命令就是在线下载一个url的静态资源
2.备份旧的yum仓库源
cd /etc/yum.repos.d
mkdir repobak
mv *.repo repobak #备份repo文件
3.下载新的阿里的yum源仓库，阿里的开源镜像站https://developer.aliyun.com/mirror/
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
4.继续下载第二个仓库 epel仓库
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
5.此时已经配置完毕，2个新的yum仓库，可以自由的嗨皮，下载软件了
[root@s25linux yum.repos.d]# ls
CentOS-Base.repo epel.repo repobak
6.下载一个redis玩一玩
[root@s25linux yum.repos.d]# yum install redis -y #就能够自动的下载redis，且安装redis
7.此时可以启动redis软件了，通过yum安装的redis，这么启动
systemctl start redis
8.使用redis的客户端命令，连接redis数据库
[root@s25linux yum.repos.d]# redis-cli
127.0.0.1:6379> ping
PONG
Linux编译python3开发环境
发博客，尝试是否能照着博客，搭建出python3的开发环境
https://www.cnblogs.com/pyyu/p/7402145.html
day04
linux下python3环境搭建
linux安装软件有哪些方式？
- rpm软件包 手动安装，拒绝此方式，需要手动解决依赖关系
- yum自动化安装，自动处理依赖关系，非常好用
- 源代码编译安装，可自定义的功能更多，指定软件安装路径
- 二进制源代码下载，此软件已经被编译安装过，生成了可执行的文件
- 下载压缩包后，直接解压缩即可使用
编译安装python3的步骤
1.很重要，必须执行此操作，安装好编译环境，c语言也是编译后运行，需要gcc编译器golang，对代码先编译，再运行，python是直接运行
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
2.获取python的源代码，下载且安装，下载源代码包的形式，自由选择
用windows的迅雷极速下载，下载完了之后，发送给linux机器即可
mac的同学，可以用scp或者等传输工具
windows的同学可以用lrzsz(yum install lrzsz -y )，xftp(自行去网站下载，支持断点续传，大文件传输)等文件传输工具
wget https://www.python.org/ftp/python/3.6.9/Python-3.6.9.tgz
3.下载完源代码包之后，进行解压缩
tar -zxvf Python-3.6.9.tgz
4.解压缩完毕之后，生成了python369的源代码目录，进入源代码目录准备开始编译
cd Python-3.6.9
5.此时准备编译三部曲 ，编译的第一曲：指定python3的安装路径，以及对系统的开发环境监测，使用如下命令
#命令解释
# configure 是一个脚本文件，用于告诉gcc编译器，python3即将安装到哪里，以及对基础的开发环境检查，检查openssl，检查sqllite，等等
# 编译第一曲，结束后，主要是生成makefile，用于编译的
[root@s25linux Python-3.6.9]# ./configure --prefix=/opt/python369/
#编译第二曲：开始进行软件编译
直接输入 make指令即可
#编译第三曲：编译安装，生成python3的可执行程序，也就是生成/opt/python369/
make install
#编译的第二曲，和第三曲，可以简写成 make && make install #代表make成功之后，继续make install
6.等待出现如下结果，表示python3编译安装结束了
Successfully installed pip-18.1 setuptools-40.6.2
7.此时可以去检查python3的可执行程序目录
[root@s25linux bin]# pwd
/opt/python369/bin
8.配置PATH环境变量 ，永久修改PATH，添加Python3的bin目录放入PATH开头位置
vim /etc/profile
写入如下内容
PATH="/opt/python369/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:"
9.手动读取/etc/profile，加载文件中的所有变量
source /etc/profile
10.检查python3的目录，以及pip3的绝对路径
[root@s25linux bin]# which pip3
/opt/python369/bin/pip3
[root@s25linux bin]# which python3
/opt/python369/bin/python3
window上安装lol的过程
1.下载lol可执行安装文件 lol.ext
2.双击安装 ，首次应该是指定lol的安装位置
3.下一步开始安装，lol会检查系统的微软的基础游戏运行组件，如果缺少某组件，游戏会安装失败(缺少什么就安装什么即可)，如果微软的开发环境正常，则正常安装
4.直到游戏安装完毕，生成可执行的游戏执行程序
5.进入游戏安装目录，开始使用
linux平台安装软件，也是这个过程，只不过用命令行代替了点点的操作
创建django项目，linux运行django
注意你的python3版本，和django的版本，是否合适！！
讲师机环境
python3.6.9
django选择用1.11.25
1.安装django模块
pip3 install -i https://pypi.douban.com/simple django==1.11.25
#检查一下pip3的模块信息
pip3 list
2.升级pip3工具
pip3 install -i https://pypi.douban.com/simple --upgrade pip
3.在linux平台，使用命令创建django项目了
django-admin startproject dj1
4.创建一个app01
[root@s25linux dj1]# django-admin startapp app01
5.编写一个视图函数，hello视图，修改app01，【访问hello视图，返回字符串，s25期的靓仔们很强】
5.1 修改django的settings.py ，注册app01 ，修改如下
#并且修改允许访问的主机列表
# 默认只允许 本地 127.0.0.1访问
# 启动在了linux的机器上 ，如果不修改windows无法访问
# 写一个 * 表示允许所有的主机访问
ALLOWED_HOSTS = ["*"]
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01',
]
5.2 先修改django的 urls.py
from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^hello/', views.hello),
]
5.3 编写django的app01.views，添加如下代码
from django.shortcuts import render,HttpResponse
def hello(requests):
return HttpResponse("s25期的靓仔们很强")
6. 进行数据库迁移
[root@s25linux dj1]# python3 manage.py migrate
6.1.指定ip和端口，启动django
[root@s25linux mysite]# python3 manage.py runserver 0.0.0.0:9000
7.如何访问django项目？
访问linux的ip地址+django的端口
8.出现无法访问的问题，要根据报错去思考，到底是什么问题
网站直接是白屏，白花花什么都看不见，
照着笔记，完成python3和django环境的搭建，运行出页面 “s25期的靓仔们很强”
linux编译安装软件的步骤
1.获取软件的源代码，去官网下载最新的，或者指定版本
2.解压缩源代码
3.进入源代码目录，开始编译三部曲，指定安装路径，make，make install
4.软件编译安装结束后，配置PATH环境变量，能够便捷的访问命令
virtualenv虚拟环境工具
需要用虚拟环境的背景
virtualenv 可以在系统中建立多个不同并且相互不干扰的虚拟环境。
python3的虚拟环境工具配置
1.下载虚拟环境工具
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv
2.通过命令行创建虚拟环境
#pip3安装的模块会放在这里
[root@s25linux ~]# find /opt/python369/ -name site-packages
/opt/python369/lib/python3.6/site-packages
# --python=python3 指定venv虚拟解释器，以哪个解释器为本体
# 这个命令如果你用相对路径，就得注意你在哪敲打的此命令
[root@s25linux opt]# virtualenv --python=python venv1
3.创建好venv1之后，需要激活方可使用，这个激活其实就是在修改PATH而已
[root@s25linux bin]# source /opt/venv1/bin/activate
(venv1) [root@s25linux bin]#
4.明确虚拟环境下venv1的解释器是干净隔离的
(venv1) [root@s25linux bin]# which python3
/opt/venv1/bin/python3
(venv1) [root@s25linux bin]#
(venv1) [root@s25linux bin]#
(venv1) [root@s25linux bin]# which pip3
/opt/venv1/bin/pip3
(venv1) [root@s25linux bin]#
(venv1) [root@s25linux bin]# pip3 list
Package Version
---------- -------
pip 20.0.2
setuptools 45.2.0
wheel 0.34.2
5.在venv1中安装django1
(venv1) [root@s25linux opt]# pip3 install -i https://pypi.douban.com/simple django==1.11.9
(venv1) [root@s25linux opt]# django-admin startproject venv1_dj119
6.再开一个ssh窗口，再创建venv2，用于运行django2 版本
virtualenv --python=python venv2
激活虚拟环境venv2
[root@s25linux opt]# source /opt/venv2/bin/activate
创建django版本2的项目
pip3 install -i https://pypi.douban.com/simple django==2.0.1
创建diango2项目
django-admin startproject venv2_dj2
7.分别启动2个版本的django，浏览器访问效果
8.deactivate #直接执行此命令，退出虚拟环境，系统会自动删除venv的PATH，也就表示退出了
利用了虚拟环境，可以分别运行多个干净、隔离的python web环境
保证开发环境，生产环境python模块一致性
软件开发的环境
小公司，服务器环境可能没那么严格（本地开发人员+测试环境+线上环境）
大公司，（本地环境+测试环境+预生产环境+线上环境）
Python web开发组
- 开发环境（windows，macOS，ubuntu，本地开发代码的一个环境），装python3 pip3项目依赖的模块
- python3环境
- mysql环境
- redis环境
- vue
- nginx
-
测试服务器，代码测试bug，以上的环境，还得再搭一遍，测试服务器才能运行项目
- 线上服务器，还得环境搭建一遍，，，，很难受。。
如何解决环境问题？
- 虚拟机的模板克隆，打包好一个基础开发环境，克隆多份，生产多个部署环境
- 利用docker容器技术的，一个镜像打包技术
在这里，是看一下
在windows开发一个项目，pip3 安装了很多的模块，最终该项目才可以运行，比如crm代码
代码上传到一个新的服务器，是一个空的环境，还得在部署一遍，比如crm代码
土办法：运行代码，查看报错，一个一个模块单独去安装解决
不那么土的办法：
pip3 freeze > requirements.txt #把你当前解释器所有用到的模块，信息导出到一个文件中
1.在windows的cmd命令行中，通过此命令导出模块信息
pip3 freeze > requirements.txt
2.把此文件发送给linux机器，或者直接拷贝其内容，也可以
在linux机器上，安装此文件即可，自动读取文件每一行的模块信息，自动安装
pip3 install -i https://pypi.douban.com/simple -r requirements.txt
本质用法：这个命令其实就是，将一个解释器的模块信息导出，丢给其他人去安装
学习阶段，模拟使用
1.在物理解释器下，安装各种模块
2.在虚拟环境下，安装此模块文件
linux启动crm项目
1.准备好crm代码，讲师的，或是自己所写的，上传至linux服务器中
lrzsz
xftp
scp
上传至服务器的代码是tf_crm.zip ，zip用unzip命令解压缩
unzip tf_crm.zip
2.新建一个虚拟环境，用于运行crm
在项目下，生成虚拟环境，便于管理此文件夹
[root@s25linux tf_crm]# virtualenv --python=python venv_crm
3.立即解决crm运行所需的模块依赖
pip3 freeze > requirements.txt
上传至linux服务器
在venv_crm虚拟环境中，安装此文件即可
如果没有此模块依赖文件，那么就手动解决吧，。。。。
此时你要注意
python3 manage.py runserver 这个命令，并不是让你启动django项目的！！！
因为此命令，调用的是python 内置的wsgiref单机socket模块，性能低下，单进程单线程。。。
#手动安装所有模块
pip3 install -i https://pypi.douban.com/simple django==1.11.25
(venv_crm) [root@s25linux tf_crm]# pip3 install -i https://pypi.douban.com/simple pymysql
(venv_crm) [root@s25linux tf_crm]# pip3 install -i https://pypi.douban.com/simple django-multiselectfield
4.缺少mysql，因此需要安装mariadb，且启动
(venv_crm) [root@s25linux tf_crm]# yum install mariadb-server mariadb -y
是否激活虚拟环境，会影响yum工具吗？
不会，因为激活虚拟环境，只是添加了一个PATH而已，只会影响python相关的操作，不会影响到其他的linux命令....
无论是否激活虚拟环境，也不会影响yum等等..
5.启动mariadb数据库
(venv_crm) [root@s25linux tf_crm]# systemctl start mariadb
6.注意可能需要修改django的settings.py有关数据库连接的账密信息等
7.还要注意，由于数据库是空的，还得进行数据库表的导入，导出本地数据库表，导出
# 参数--all-databases能够导出所有的数据库，表，也可以指定某一个数据库。表导出
大家使用此命令行就可以了！！！！导出所有的库表，然给交给linux导入
大家使用此命令行就可以了！！！！导出所有的库表，然给交给linux导入
大家使用此命令行就可以了！！！！导出所有的库表，然给交给linux导入
mysqldump -uroot -p --all-databases > alldb.sql
#冯浩敲打的命令，如下，指定数据库导出
# -d 参数是只导出表结构，不要表中的数据
mysqldump -uroot -p123 -d tf_crm > tf_crm.sql
8.发送此alldb.sql文件，给linux机器，再进行数据导入
就是将第七步的SQL文件，通过lrzsz、scp、xftp等方式，发送此文件，给linux
mysql -uroot -p < /opt/alldb.sql
9.此时再次尝试启动crm项目
(venv_crm) [root@s25linux tf_crm]# python3 manage.py runserver 0.0.0.0:9090
mysql导出数据的命令
数据库备份与恢复
mysqldump命令用于备份数据库数据
[root@master ~]# mysqldump -u root -p --all-databases > /tmp/db.dump
2.导出db1、db2两个数据库的所有数据
mysqldump -uroot -proot --databases db1 db2 >/tmp/user.sql
部署步骤并不难，做好笔记，按照流水线来操作即可
vue前后端分离的部署，难度会+1
virtualenvwrapper是吧，那个是virtualenv的升级版，用哪个都一样，都是创建多个虚拟环境
virtualenv不支持查看所有虚拟环境，virtualenvwrapper支持，是 lsvirtualenv命令
uwsgi启动python web
让你的django在linux上，支持并发形式启动，支持多进程，多线程，乃至于协程的一个C语言编写的高性能工具
1.安装uwsgi工具
pip3 install -i https://pypi.douban.com/simple uwsgi
2.编写uwsgi.ini配置文件，以多进程形式启动tf_crm
touch uwsgi.ini #手动创建此uwsgi的配置文件，写入如下的内容参数，去启动crm
# 写入如下的功能性的参数配置，用于启动项目
# 这些部署的流程，是国外的uwsgi官网，给与的用法，我们照着用即可
# 注意要根据你自己的目录，修改如下的参数
[uwsgi]
# Django-related settings
# the base directory (full path)
# 填写crm项目的第一层绝对路径
chdir = /opt/tf_crm/
# Django's wsgi file
# 填写crm项目第二层的相对路径，找到第二层目录下的wsgi.py
# 这里填写的不是路径，是以上一个参数为相对，找到第二层项目目录下的wsgi.py文件
module = tf_crm.wsgi
# the virtualenv (full path)
# 填写虚拟环境解释器的第一层工作目录
home = /opt/tf_crm/venv_crm
# process-related settings
# master
master = true
# maximum number of worker processes
# 代表定义uwsgi运行的多进程数量，官网给出的优化建议是 2*cpu核数+1 ，单核的cpu填写几?
# 如果是单进程，十万个请求，都丢给一个进程去处理
# 3个工作进程，十万个请求，就分给了3个进程去分摊处理
processes = 3
# the socket (use the full path to be safe
# 这里的socket参数，是用于和nginx结合部署的unix-socket参数，这里临时先暂停使用
# socket = 0.0.0.0:8000
# 线上不会用http参数，因为对后端是不安全的，使用socket参数是安全的连接，用nginx反向代理去访问
# 后端程序是运行在防火墙内部，外网是无法直接访问的
# 临时使用http参数，便于我们用浏览器调试访问
http = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket = 664
# clear environment on exit
vacuum = true
3.此时可以用命令，基于uwsgi协议的一个高性能web后端启动了
uwsgi --ini ./uwsgi.ini #指定配置文件启动后端
4.此时crm项目，已经用uwsgi支持了3个进程的启动了，但是由于uwsgi对静态文件的解析性能很弱，线上是丢给nginx去处理的
5.未完待续。。。留在部署时候再讲
day05
昨日作业标题
1.编译安装好python3
2.练习linux运行一个简单的django项目
Pip3安装django模块
通过django-admin命令生成项目文件夹
简单修改django的项目文件夹，配置文件修改
即可启动访问
3.安装配置好virtualenv工具，可以在linux下创建出多个隔离的，干净的，多个python3解释器
创建venv1运行django版本1
创建venv2运行django版本2
4.完成linux上启动所教的crm项目,能够登录查看用户数据（配置好数据库），截图展示
5.
原本是通过python3 manage.py runserver这种方式启动项目，仅仅是用于调试项目是否正常运行的命令
线上就是更换了启动方式
安装uwsgi工具，写好配置文件，启动django项目即可
装好uwsgi工具，使用uwsgi.ini配置文件，启动crm项目，截图展示，静态文件丢失暂时忽略
遇见的问题
44个同学交了作业，每天上课57人， 有13个没交的，需要告诉我是什么问题，班主任会帮忙跟进
基本都是完成到第三题
1.看来编译python3环境基本没问题
2.linux简单启动django 基本也没问题
3.安装虚拟环境工具，使用问题也没问题
4.主要是到了启动crm，涉及的操作较多
照着上课笔记+视频，梳理好笔记，应该一、二、三做些什么，遇见问题及时和我沟通
------
4，5没做,或是遇见了错误问题
后面课程安排
应该是补充四天linux课程，linux结束就是python开发项目复习+串讲
- Nginx虚拟主机配置
- 多虚拟主机配置
- 访问日志功能
- 404页面优化
- 反向代理功能
- 负载均衡配置，负载均衡算法介绍
- Nginx结合uwsgi，进行项目部署
- Nginx+vue+uwsgi+mariadb+redis，进行路飞学城部署
- redis数据库
- 五大数据类型
- 数据持久化机制
- 主从复制
- 主从复制-高可用-哨兵功能
- redis集群搭建
- docker容器技术
- 容器，镜像，仓库的基本管理
- dockerfile实战
- Saltstack，rabbitmq
今日任务
- supervisor工具使用，进程管理工具
- nginx
supervisor工具
目前你所学的linux技能
对crm的进程进行管理，启停
ps -ef|grep python3
ps -ef|grep uwsgi #检查uwsgi的进程，确认django是否存活，假如检测到pid是 5999
停止uwsgi，kill -9 5999
#检测uwsgi如果挂掉之后，自动帮你重启
#使用supervisor这个python开发的进程管理工具，用它启动uwsgi之后，uwsgi进程挂掉后，自动会再启动
比如，crm的部署技术栈
nginx+uwsgi+django+mysql ，我们可以手动的，单独启动每一个进程
还可以通过supervisor一键启动这四个进程，进行批量管理，批量启停 ，很好用
安装supervisor工具
1.使用yum命令即可直接安装
[root@s25linux ~]# yum install supervisor -y
2.生成supervisor的配置文件
[root@s25linux ~]# echo_supervisord_conf > /etc/supervisord.conf
3.修改supervisor的配置文件，添加管理crm的任务
vim /etc/supervisor.conf #再最底行，添加如下内容
#[program:xx]是被管理的进程配置参数，xx是进程的名称
[program:s25crm]
command=写入启动uwsgi的命令 ;supervisor其实就是在帮你执行命令而已！
autostart=true ; 在supervisord启动的时候也自动启动
startsecs=10 ; 启动10秒后没有异常退出，就表示进程正常启动了，默认为1秒
autorestart=true ; 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启
stopasgroup=true ;默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程
killasgroup=true ;默认为false，向进程组发送kill信号，包括子进程
master--工头进程，主人进程--突然工头挂了..
worker---主进程突然挂了，工作进程就变为了僵尸进程，
worker
worker
因此，杀死uwsgi，需要向这个进程组，发送终止信号，杀死一组进程
再次在linux系统上使用uwsgi启动crm的配置笔记
还不会的同学，，可认真听了~~~~
1.编译安装好python3的开发环境
讲师机器环境是：/opt/python369/bin/python3
以及pip3的绝对路径：/opt/python369/bin/pip3
2.生成一个新的虚拟环境，去运行crm，以及uwsgi
pip3 install -i https://pypi.douban.com/simple virtualenv #安装虚拟环境工具
通过命令生成新的虚拟环境
virtualenv --python=python3 venv_crm_again
[root@s25linux opt]# source venv_crm_again/bin/activate
(venv_crm_again) [root@s25linux opt]# echo $PATH
/opt/venv_crm_again/bin:/opt/python369/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin::/root/bin
3.在虚拟环境下，安装，crm所需的模块信息
pip3 install -i https://pypi.douban.com/simple -r requirements.txt
#此模块依赖文件的信息，如下，大家也可以手动的复制粘贴，也可以~~~
(venv_crm_again) [root@s25linux tf_crm]# cat requirements.txt
Django==1.11.25
django-multiselectfield==0.1.11
PyMySQL==0.9.3
pytz==2019.3
uWSGI==2.0.18
4.模块依赖解决了，检查你是否需要修改crm项目的settings.py
修改如下参数ALLOWED_HOSTS = ["*"]
5.注意需要启动mysql，提前配置好yum源，阿里云的yum源，如果下载过慢，怎么办？
择优dns选择，不同的dns服务器，解析速度也有快慢之分，就好比移动，联通信号由快慢一样
可以在腾讯，阿里云，114的dns服务器之间做选择
dns劫持，dns被人劫持了，你访问baidu.com ，强制给你解析到某恶意网站的ip上，因此浏览器看到不一样的内容了
#填入2个阿里的dns服务器地址
vim /etc/resolv.conf #
nameserver 223.5.5.5
nameserver 223.6.6.6
yum install mariadb-server mariadb -y
#启动mysql
systemctl start mariadb
systemctl status mariadb
#从windows中导出数据
mysqldump -uroot -p --database tf_crm > tf_crm.sql #这个命令是在cmd命令行敲的！！！！
#发送此sql文件，给linux，进行数据导入
mysql -uroot -p tf_crm < tf_crm.sql #数据导入的命令，注意，你linux的机器，得提前创建tf_crm库！！
6.尝试调试crm，是否能够运行
python3 manage.py runserver 0.0.0.0:7777 #可以查看到页面后，表示此项目可以用uwsgi部署了
7.下载安装uwsgi工具，写好uwsgi.ini配置文件
pip3 install -i https://pypi.douban.com/simple uwsgi -y
touch uwsgi.ini #写入如下内容
[uwsgi]
# Django-related settings
# the base directory (full path)
# 填写crm项目的第一层绝对路径
chdir = /opt/tf_crm/
# Django's wsgi file
# 填写crm项目第二层的相对路径，找到第二层目录下的wsgi.py
# 这里填写的不是路径，是以上一个参数为相对，找到第二层项目目录下的wsgi.py文件
module = tf_crm.wsgi
# the virtualenv (full path)
# 填写虚拟环境解释器的第一层工作目录
home = /opt/venv_crm_again
# process-related settings
# master
master = true
# maximum number of worker processes
# 代表定义uwsgi运行的多进程数量，官网给出的优化建议是 2*cpu核数+1 ，单核的cpu填写几?
# 如果是单进程，十万个请求，都丢给一个进程去处理
# 3个工作进程，十万个请求，就分给了3个进程去分摊处理
processes = 3
# the socket (use the full path to be safe
# 这里的socket参数，是用于和nginx结合部署的unix-socket参数，这里临时先暂停使用
# socket = 0.0.0.0:8000
# 线上不会用http参数，因为对后端是不安全的，使用socket参数是安全的连接，用nginx反向代理去访问
# 后端程序是运行在防火墙内部，外网是无法直接访问的
# 临时使用http参数，便于我们用浏览器调试访问
http = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket = 664
# clear environment on exit
vacuum = true
接着上面的笔记
8.uwsgi和uwsgi.ini都配置完毕之后，开始使用supervisor工具进行管理了
先明确，启动uwsgi的绝对路径命令是什么
8.1 找到uwsgi的绝对路径 /opt/venv_crm_again/bin/uwsgi
8.2 找到uwsgi.ini的绝对路径 /opt/tf_crm/uwsgi.ini
8.3 因此 启动 crm项目的 完整绝对路径命令是
/opt/venv_crm_again/bin/uwsgi --ini /opt/tf_crm/uwsgi.ini
9.修改supervisor的配置文件
vim /etc/supervisord.conf #写入如下
[program:s25crm]
command=/opt/venv_crm_again/bin/uwsgi --ini /opt/tf_crm/uwsgi.ini ;supervisor其实就是在帮你执行命令而已！
autostart=true ; 在supervisord启动的时候也自动启动
startsecs=10 ; 启动10秒后没有异常退出，就表示进程正常启动了，默认为1秒
autorestart=true ; 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启
stopasgroup=true ;默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程
killasgroup=true ;默认为false，向进程组发送kill信号，包括子进程
10.启动supervisor，默认就会直接启动uwsgi了
supervisord -c /etc/supervisord.conf #启动supervisor服务端，指定配置文件启动
启动完毕supervisor之后，检查进程信息
ps -ef|grep supervisor #检查supervisor是否存在了进程，是否启动
ps -ef|grep uwsgi #检查uwsgi是否启动
11.进度supervisor任务管理终端
看到如下的结果，表示你自定义的任务s25crm，也就是uwsgi进程，正确的启动了
supervisorctl -c /etc/supervisord.conf
(venv_crm_again) [root@s25linux tf_crm]# supervisorctl -c /etc/supervisord.conf
s25crm RUNNING pid 41451, uptime 0:01:34
supervisor>
12.看到了没有静态文件的 crm界面，就是正确的了
13.supervisorctl的管理命令
提供了如下命令
(venv_crm_again) [root@s25linux tf_crm]# supervisorctl -c /etc/supervisord.conf
s25crm RUNNING pid 41451, uptime 0:01:34
supervisor>
supervisor>start s25crm
supervisor>stop s25crm
supervisor>status
supervisor>start all
supervisor>stop all
14.uwsgi异常崩溃的话，supervisor会立即重启uwsgi
15.如果要运行多个 uwsgi项目，在supervisor中定义多个任务即可
nginx学习
需要装2个虚拟机
nginx 官方nginx
tenginx 淘宝nginx
这2个一模一样，淘宝的nginx，官方文档更详细
小提示： 如果你想删除 编译安装的软件 1，清空PATH 2，删除文件夹即可
注意，编译软件之前，还是需要解决系统的开发环境，例如如下
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
1.进入淘宝nginx官网，下载源代码，进行编译安装
http://tengine.taobao.org/index_cn.html
2.在linux的opt目录下，下载nginx源代码
wget http://tengine.taobao.org/download/tengine-2.3.2.tar.gz
3.解压缩源代码，准备编译三部曲
[root@s25linux opt]# tar -zxvf tengine-2.3.2.tar.gz
4.进入源码目录，指定nginx的安装位置
[root@s25linux tengine-2.3.2]# ./configure --prefix=/opt/tngx232/
5.编译且编译安装，生成nginx的可执行命令目录
make && make install
6.安装完毕后，会生成/opt/tngx232/文件夹，nginx可以使用的配置都在这里了
[root@s25linux tngx232]# ls
conf html logs sbin
conf 明显是存放*.conf配置文件的
html 存放网页的静态文件的目录
logs 日志
sbin 存放nginx的可执行命令
7.添加nginx到PATH中，可以快捷执行命令
永久修改PATH，开机就去读
vim /etc/profile
写入PATH="/opt/tngx232/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:"
8.首次启动nginx，注意要关闭防火墙
直接输入nginx命令即可启动
有关nginx的命令
nginx #首次输入是直接启动，不得再次输入
nginx -s reload #平滑重启，重新读取nginx的配置文件，而不重启进程
nginx -s stop #停止nginx进程
nginx -t #检测nginx.conf语法是否正确
9.默认访问nginx的首页站点url是
http://192.168.178.140:80/index.html
nginx的配置文件学习
nginx的配置文件是c语言的代码风格
以; 号 表示每一行配置的结束
nginx.conf中 是以代码块形式 编写的
例如 主要的几个代码块
http{ } #里面定义了多个代码，是nginx的核心功能配置点
server{ } #虚拟主机代码块，定义了网站的目录地址，以及首页文件名字，监听的端口，等等功能
location { } #域名匹配代码块。。
####比喻代码块的含义
def hello():
我是缩进，被hello这个函数 控制
我们都是缩进内的代码块。。。
func hello(){
我们都是在花括号内的代码。。
我们是各改代码块。。。。
}
课上的nginx.conf 注释如下
#user nobody;
# 定义nginx的工作进程数，以cpu核数 为准
worker_processes 5;
# 想用哪个用能，直接打开注释，或者写进来即可
error_log logs/error.log;
#error_log logs/error.log notice;
#error_log logs/error.log info;
#error_log "pipe:rollback logs/error_log interval=1d baknum=7 maxsize=2G";
# pid文件的作用是，pid是用于启停进程的号码
# ps -ef去获取nginx的进程id
# 吧pid写入到 此 nginx.pid文件中，
pid logs/nginx.pid;
events {
worker_connections 1024;
}
# 这个http区域，是nginx的核心功能区域
http {
include mime.types;
default_type application/octet-stream;
#打开此nginx的访问日志功能，即可查看日志
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;
sendfile on;
#tcp_nopush on;
#keepalive_timeout 0;
keepalive_timeout 65;
#nginx开启静态资源压缩，比如nginx返回磁盘的html文件特别大，里面包含了诸多的js css，图片引用
# 一个html文件 达到4m大小
# 传输图片 等等都是高兴的 1080p图片
# 打开此功能，能够极大的提升网站访问，以及静态资源压缩
gzip on;
# 提供静态资源缓存功能，第一次访问过网页之后，nginx能够让图片js等静态资源，缓存到浏览器上
# 浏览器下次访问网站，速度就几乎是秒开了
# 想要用这些功能，只需要在nginx里打开某些配置即可，作者都已经写好了该功能
#
#这里的server区域配置，就是虚拟主机的核心配置
# nginx支持编写多个server{} 区域块，以达到多虚拟主机，多个站点的功能
# server{} 区域块，可以存在多个，且默认是自上而下去加载，去匹配的
# 目前这里是第一个server {} 区域块，端口是85
server {
# 定义该网站的端口
listen 85;
#填写域名，没有就默认即可
server_name localhost;
#更改nginx的编码支持
charset utf-8;
# 如此添加一行参数，当用户请求出错，出现404的时候，就返回 root定义的目录去寻找40x.html文件
# 讲师机器的配置，也就是去 /s25python/ 这个目录下 寻找 40x.html
error_page 404 /40x.html;
#access_log logs/host.access.log main;
#access_log "pipe:rollback logs/host.access_log interval=1d baknum=7 maxsize=2G" main;
# nginx的域名匹配，所有的请求，都会进入到这里
# 例如 192.168.178.140:85/lubenwei.jpg
# 192.168.178.140:85/menggededianhua.txt
location / {
#这个root参数，是定义该虚拟主机，资料存放路径的，可以自由修改
# 当用户访问 192.168.178.140:85的时候，就返回该目录的资料
root /s25python/;
# index参数，用于定义nginx的首页文件名字 ，只要在/s25nginx目录下存在index.html文件即可
index index.html index.htm;
}
}
#这里就是上一个Server{}的标签闭合处了，，可以写入第二个server{}
# 注意 ，注意，server{} 标签快，是平级的关系，不得嵌套，检查好你的花括号
# 这里是第二个虚拟主机的配置了
server {
listen 89;
server_name _;
#nginx的域名匹配
# 当用户访问 192.168.178.140:89的时候，返回该目录的内容
location / {
root /s25linux/;
index index.html;
}
}
}
nginx的web站点功能
也称之为是nginx的虚拟主机站点配置
指的就是在nginx中，能够通过文件目录的不同，可以定义多个不同的网站
修改nginx的首页内容，你们信不信我，一分钟做出一个dnf(腾讯的游戏官网)的官网~ 相信的扣1，觉得我在吹牛皮的，扣2
1.如何修改nginx的首页地址，进入html目录下，找到index.html文件，默认读取的是这个文件
[root@s25linux html]# pwd
/opt/tngx232/html
[root@s25linux html]# ls
50x.html index.html
2.在自己的站点下，存放一些静态资料，如gif，jpg等
[root@s25linux html]# ls
50x.html 55kai.jpg index.html s25.html
nginx的多站点功能
- 基于域名的多虚拟主机
修改hosts文件，强制写入域名对应关系，比较麻烦
- 基于端口的多虚拟主机
1.修改nginx.conf配置如下，定义2个server{} 区域块即可
第一个虚拟主机的配置
# 目前这里是第一个server {} 区域块，端口是85
server {
# 定义该网站的端口
listen 85;
#填写域名，没有就默认即可
server_name localhost;
#更改nginx的编码支持
charset utf-8;
#access_log logs/host.access.log main;
#access_log "pipe:rollback logs/host.access_log interval=1d baknum=7 maxsize=2G" main;
# nginx的域名匹配，所有的请求，都会进入到这里
# 例如 192.168.178.140:85/lubenwei.jpg
# 192.168.178.140:85/menggededianhua.txt
location / {
#这个root参数，是定义该虚拟主机，资料存放路径的，可以自由修改
# 当用户访问 192.168.178.140:85的时候，就返回该目录的资料
root /s25python/;
# index参数，用于定义nginx的首页文件名字 ，只要在/s25nginx目录下存在index.html文件即可
index index.html index.htm;
}
}
第二个虚拟主机的配置
#这里就是上一个Server{}的标签闭合处了，，可以写入第二个server{}
# 注意 ，注意，server{} 标签快，是平级的关系，不得嵌套，检查好你的花括号
# 这里是第二个虚拟主机的配置了
server {
listen 89;
server_name _;
#nginx的域名匹配
# 当用户访问 192.168.178.140:89的时候，返回该目录的内容
location / {
root /s25linux/;
index index.html;
}
}
改完配置文件后，分别创建2个站点的资源目录
[root@s25linux conf]#
[root@s25linux conf]# mkdir /s25linux /s25python
[root@s25linux conf]#
[root@s25linux conf]#
[root@s25linux conf]# echo "i like linux ,i very happy" > /s25linux/index.html
[root@s25linux conf]#
[root@s25linux conf]#
[root@s25linux conf]# echo "i use python,i very nb" > /s25python/index.html
#注意，改了配置文件，一定要平滑重启，否则不生效
[root@s25linux conf]# nginx -s reload
#此时分贝访问2个站点，即可看到2个站点的资料
192.168.178.140:85
192.168.178.140:85
nginx的404页面优化
如果nginx不做404优化，那么页面是非常丑的。。
1.修改nginx.conf，修改一行参数即可
server {
# 定义该网站的端口
listen 85;
#填写域名，没有就默认即可
server_name localhost;
#更改nginx的编码支持
charset utf-8;
# 如此添加一行参数，当用户请求出错，出现404的时候，就返回 root定义的目录去寻找40x.html文件
# 讲师机器的配置，也就是去 /s25python/ 这个目录下 寻找 40x.html
error_page 404 /40x.html; #注意别忘了分号
......
手动创建一个40x.html，咱们也可以去网上搜索404的html模板，修改此40x.html即可
[root@s25linux conf]# cat /s25python/40x.html
<meta charset=utf8>
我是自定义的404页面，你看我美不美...
注意还得重启nginx
nginx -s reload
Nginx的访客日志
nginx的方可日志，能够记录，分析用户的请求行为
-什么时间点，访问的最频繁，比如路飞的网站，网站的流量，基本都在晚上，学生下了班，在线学习各种技术
-记录用户的请求频率，以此检测是否是爬虫等恶意请求，进行封禁。
-检测躲在代理ip后的 真实用户ip
-检测用户ip，请求时间，请求的url内容，等等。。。。
如何配置日志呢
修改nginx.conf 在 http{}代码块中，打开如下注释即可
#打开此nginx的访问日志功能，即可查看日志
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
#如果25期所有学生，在班级，同时访问路飞官网
# nginx日志检测到的ip地址是一样，还是不一样的？
# 答案是一样的，因为大家都从同一路由器转发出去的公网
# 我们都是通过同一个宽带运营商提供的公网ip和路飞通信的
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 客户端身份信息，以此可以nginx判断，用户客户端是手机浏览器，就转发移动端页面给与用户
如果是pc的客户端，就转发给pc页面给与用查看
$http_x_forwarded_for 记录客户端的来源真实ip 97.64.34.118，机器A用机器B的ip去访问，可以抓出机器A的地址，这个参数不是万能的，爬虫和反扒是相互的。。。
重启nginx -s reload
实时监测访客日志的信息
nginx反向代理
反向代理
反向，代理
代理是什么？你在生活中见过那些代理的事儿？
如下的几种代理情况
海外代购
我们再国内，想买的东西买不到，，------> 代购 -----> 国外的产品
我们拿到东西 <-------代理(人肉拿回来，寄回来)<-------国外的产品
租房的中介
你刚来北京，要住房 ，怎么办？
找中介，支付中介费
由于房东一般很难找到，或者说不想和客户直接打交道
超哥要租房 -------> 找到中介(只是做了一个中间人，租房请求转达给了房东) ------>房东(资源属于房东)
超哥拿到房子的钥匙<------中介（拿到资源后，转发给用户）<-------房东
直接找到房东本人的
用户----> 房东
用户<---房东
买票，黄牛这个代理
超哥想过年回家买票，，直接去12306买不着
用户买票------>找黄牛----->拿到资源
用户拿票<----黄牛<------某资源
---------
在技术领域的反向代理
正向代理，，代理服务器，代理的是客户端
反向代理，，代理服务器，，代理的是服务端
反向代理，实验配置
讲道理，需要准备2台linux服务器
192.168.178.134
192.168.178.140
考虑到咱们同学的笔记本，安装2个虚拟机会比较卡，
因此决定用如下的方案，很巧妙，用到了nginx支持的多虚拟主机功能
准备1台机器即可
如192.168.178.140 ，基于端口的不同，运行不同的站点
1.准备一台linux机器，安装好nginx之后，，修改nginx.conf如下，配置好2个server{}标签
第一个server{}标签，用于反向代理的作用，修改nginx.conf如下
# 第一个虚拟主机的配置，作用是反向代理了
#
server {
listen 80;
server_name localhost;
charset utf-8;
error_page 404 /40x.html;
# 这里的locaiton 路径匹配，如果你写的是root参数，就是一个web站点功能
# 如果你写的是proxy_pass参数，就是一个请求转发，反向代理功能
location / {
#当请求发送给 192.168.178.140:80的时候
#直接通过如下的参数，转发给90端口
proxy_pass http://192.168.178.140:90;
}
}
第二个server{}标签，作用是返回机器上的资料，也就是一个web站点的功能
#第二个虚拟主机，作用是web站点功能，资源服务器，提供页面的
server {
listen 90;
server_name _;
#当请求来到 192.168.178.140:90的时候，就返回/s25proxy目录下的index.html
location / {
root /s25proxy/;
index index.html;
}
}
创建资源文件夹，以及html页面内容
[root@s25linux conf]# cat /s25proxy/index.html
<meta charset=utf8>
我是资源服务器，我是192.168.178.140 的90端口
重启nginx
nginx -s reload
nginx负载均衡
nginx负载均衡实验的搭建
1.修改nginx.conf如下
第一个虚拟主机server{}的作用，是反向代理，80端口
# 用upstream关键词定义负载均衡池，写入资源服务器的地址
# 负载均衡的算法，默认是轮询机制，一台服务器处理一次
upstream s25real_server {
server 192.168.178.140:90;
server 192.168.178.140:95;
}
server {
listen 80;
server_name localhost;
charset utf-8;
error_page 404 /40x.html;
# 这里的locaiton 路径匹配，如果你写的是root参数，就是一个web站点功能
# 如果你写的是proxy_pass参数，就是一个请求转发，反向代理功能
location / {
#当请求发送给 192.168.178.140:80的时候
#直接通过如下的参数，转发给90端口
proxy_pass http://s25real_server;
}
}
第二个server{}标签的配置，作用是提供资源给用户看的，90端口
#第二个虚拟主机，作用是web站点功能，资源服务器，提供页面的
server {
listen 90;
server_name _;
#当请求来到 192.168.178.140:90的时候，就返回/s25proxy目录下的index.html
location / {
root /s25lol/;
index index.html;
}
}
第三个server{}标签的作用，同样是返回资源页面，查看负载均衡效果的，95端口
#第三个server{}虚拟主机，作用是 提供资源服务器的内容的
server {
listen 95;
server_name _;
location / {
root /s25dnf/;
index index.html;
}
}
此时分别准备2个资源服务器的内容
准备好 /s25lol/index.html
准备好 /s25dnf/index.html
nginx负载均衡算法
1.默认是轮询机制，每台服务器处理一次
2.加权轮询，修改nginx.conf如下，给与机器不同的权重
upstream s25real_server {
server 192.168.178.140:90 weight=4;
server 192.168.178.140:95 weight=1;
}
day06
今日内容
对于python web后端而言，linux学习阶段，部署是最锻炼你操作，以及对linux系统的熟悉程度的
crm纯后端部署
supervisor+nginx+uwsgi+django+virtualenv+mariadb
crm部署流程笔记
crm是通过模板语言进行和前端通信的 ，前端代码写在后端中
{{static.el}}
如何停止supervisor以及uwsgi
1.必须得先停止supervisor才可以停止uwsgi
pkill -9 supervisor
2.杀死uwsgi
pkill -9 uwsgi
kill命令，是基于pid杀死进程，如 kill 5888
pkill命令， 是基于进程的名字 杀死进程 pkill uwsgi
crm部署的史上最详细的流程部署笔记
#先从后端搞起 uwsgi+crm进行项目运行
老师电脑的环境变量
PATH="/opt/python369/bin:/opt/tngx232/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:"
1.先创建虚拟环境，用于运行crm
(s25_crm) [root@s25linux s25crm]#
2.上传代码到linux中，调试项目是否能够运行
pip3 install -i https://pypi.douban.com/simple django==1.11.25
pip3 install -i https://pypi.douban.com/simple pymysql
pip3 install -i https://pypi.douban.com/simple django-multiselectfield
3.在调试好crm的模块依赖，以及mariadb数据库的安装，以及数据导入之后（数据导入出错了，基本事sql文件的问题，单独找我）,crm调试可以正确运行了
4.在线上，是使用uwsgi结合uwsgi.ini配置文件，启动crm的，因此 ，启动方式如下
pip3 install -i https://pypi.douban.com/simple uwsgi #安装uwsgi
#今日的线上部署，uwsgi.ini需要修改的地方是，添加如下参数，关闭http参数
#今日的线上部署，uwsgi.ini需要修改的地方是，添加如下参数，关闭http参数
#今日的线上部署，uwsgi.ini需要修改的地方是，添加如下参数，关闭http参数
# 这里的socket参数，是用于和nginx结合部署的unix-socket参数，这里临时先暂
停使用
# 使用此协议运行后台，就无法通过浏览器访问了，协议不一样
socket = 0.0.0.0:8000
# 线上不会用http参数，因为对后端是不安全的，使用socket参数是安全的连接>，用nginx反向代理去访问
# 后端程序是运行在防火墙内部，外网是无法直接访问的
# 临时使用http参数，便于我们用浏览器调试访问
#http = 0.0.0.0:8000
5.使用supervisor启动uwsgi进程，需要修改supervisord.conf配置文件了，看好文件的名字！！！！
vim /etc/supervisord.conf #修改如下参数
[program:again_s25crm]
command=/s25crm/s25_crm/bin/uwsgi --ini /s25crm/tf_crm/uwsgi.ini
autostart=true ; 在supervisord启动的时候也自动启动
startsecs=10 ; 启动10秒后没有异常退出，就表示进程正常启动了，默认为1秒
autorestart=true ; 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启
stopasgroup=true ;默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程
killasgroup=true ;默认为false，向进程组发送kill信号，包括子进程
6.检查后台的状态，以及启动命令
【但凡supervisor这里无法正常启动，立即去检查 supervisord.conf里面定义的任务参数是否正确】
(s25_crm) [root@s25linux tf_crm]# supervisord -c /etc/supervisord.conf
Unlinking stale socket /tmp/supervisor.sock
(s25_crm) [root@s25linux tf_crm]# supervisorctl -c /etc/supervisord.conf
again_s25crm STARTING
supervisor>
supervisor>
supervisor> status
again_s25crm STARTING
supervisor> status
again_s25crm RUNNING pid 64285, uptime 0:00:13
7.此时配置好nginx.conf就完事了，修改如下，配置nginx，请求转发给后台即可
server {
listen 80;
server_name localhost;
#这是一个局部的变量，只对当前这个server{}代码块生效，编码设置为utf-8
charset utf-8;
error_page 404 /40x.html;
# 这里的locaiton 路径匹配，如果你写的是root参数，就是一个web站点功能
# 基于uwsgi协议的一个高性能的反向代理转发，新的参数
location / {
#当请求发送给 192.168.178.140:80的时候
#通过uwsgi_pass把请求转发给后端的uwsgi服务器
uwsgi_pass 0.0.0.0:8000;
#这个参数，是固定的，是添加一些转发请求头内容
include uwsgi_params;
}
}
8.重启nginx
nginx -s reload
8.1 此时发现静态文件丢失，例如如下的静态文件
http://192.168.178.143/static/js/common.js
http://192.168.178.143/static/css/style.css
http://192.168.178.143/static/js/jquery.validate.min.js
9.还得配置nginx接收所有的django静态文件，修改命令如下
第一步：修改django的配置文件，收集所有的静态文件，放入一个统一管理的目录
vim settings.py #添加如下内容
STATIC_ROOT='/s25static/' #作用是定义一个统一管理的目录，收集所有crm的静态文件
第二步：用命令收集静态文件
python3 manage.py collectstiac
10.通过nginx去找到如下的静态文件即可
location /static/{
alias /tf_crm_static/;
}
今天的第一大任务
- 使用supervisor启动crm，uwsgi+django
- 用nginx反向代理请求给crm，并且处理好静态文件，能够登录项目检查数据，完成如下页面
-
路飞前后端分离部署
vue+nginx+uwsgi+django+mariadb+redis
vue打包之后，生成了dist静态文件夹 ，前端的静态文件，都在这里了，静态文件，都是丢给nginx直接去返回即可
vue的dist静态文件，运行之后，能够立即看到路飞的首页内容了，此时还没有和后端的数据交互
当你在前端的单页面应用中，点击课程列表，向后台发送 ajax请求，提交post
vue请求课程列表的post请求，应该是发给谁去处理的？ 答案是 DRF后台去处理的
注意在线上部署的架构图流程中，，django后台，是躲在了防火墙之后的，只能通过nginx反向代理去访问...
路飞前后端分离部署的 示意图，需要理解下
前后端分离部署的详细笔记流程
从前端搞起？还是后端搞起？
从前端搞起
我是在配置node的环境，用于 npm run build 对前端的vue代码，进行打包，这个还记得吗？？
1.获取前端vue的项目代码
(s25_crm) [root@s25linux s25luffy]# wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip
2.解压缩代码，进行编译打包vue的代码，注意要配置nodejs环境
unzip 07-luffy_project_01.zip
3.配置nodejs环境，下载nodejs源码包
这里特殊的是，老师给的这个地址，是node的二进制源码包，是已经编译完成了的node解释器
直接解压缩，配置PATH即可，无需再编译了
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的环境变量，如下
vim /etc/profile
PATH="/opt/python369/bin:/opt/tngx232/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/s25luffy/node-v8.6.0-linux-x64/bin"
4.重新读取/etc/profile，加载node的环境，查看是否正常
source /etc/profile
[root@s25linux ~]# node -v
v8.6.0
[root@s25linux ~]# npm -v
5.3.0
5.进入vue的代码目录下，修改数据提交地址，这一步非常重要!!!!!!!!!
// 这里是 vue页面运行之后，出发js的数据提交动作，向某个地址，发出了请求，这个地址对吗？？？
// 为什么不对呢？是因为，vue向当前机器的本地，去发送请求了，是错的！！！！
// 应该向后台服务器 去发送请求！！！
// 那么，我应该发给谁呢？？？
// 我应该 发给 刚才和大家聊的 9000端口，还是 9005端口呢？？
// 没问题，这里的数据提交地址，应该发给 代理服务器，也就是 9000端口，然后再通过9000端口，转发给uwsgi，也就是9005端口
批量修改的命令如下
sed命令，是用于文本内容处理的 强大命令，可以直接替换文件中的内容
比如notapad++的全局替换 功能
#sed命令 -i参数 是 把替换结果写入到文件
# 's/127.0.0.1:8000/192.168.178.143:9000/g'
# s是替换指令 /你要替换的内容/替换之后的内容/ g 是 全局替换，global的意思
[root@s25linux 07-luffy_project_01]# sed -i 's/127.0.0.1:8000/192.168.178.143:9000/g' src/restful/api.js
6.明确vue的数据提交地址，正确修改之后，开始安装node的依赖
就好比 python项目要运行，需要安装pip3模块一样
node项目要运行，也需要npm install package.json #安装模块呀。。。。
#我敲打的这个命令，是更换npm的源的含义，加速下载
# --registry https://registry.npm.taobao.org 这是临时更换淘宝源的含义。。。
# 结尾什么都不跟上，默认是安装当前路径的 package.json文件
[root@s25linux 07-luffy_project_01]# npm --registry https://registry.npm.taobao.org install
7.安装完node的模块之后，开始编译vue
npm run build
8.此时应该会生成了dist文件夹，直接丢给nginx去返回页面即可，由于学习阶段，80端口已经给crm项目用了，因此路飞换成81端口
9.修改nginx.conf，添加一个server{}虚拟主机，返回路飞的页面
vim nginx.conf
#添加第二个虚拟主机 ，给路飞使用
server {
listen 81;
server_name _;
location / {
#直接返回vue的打包内容即可
root /s25luffy/07-luffy_project_01/dist;
index index.html;
}
路飞的前端配置结束，马上配置后端
路飞DRF后端部署笔记
1.获取drf项目代码，本地上传，git克隆
wget https://files.cnblogs.com/files/pyyu/luffy_boy.zip
2.解压缩项目代码，之后，安装依赖，使用虚拟环境管理不同的项目
virtualenv --python=python3 s25_luffy
[root@s25linux luffy_boy]# source s25_luffy/bin/activate
(s25_luffy) [root@s25linux luffy_boy]#
3.解决路飞后台代码，所需的依赖，下载requirements.txt文件即可
(s25_luffy) [root@s25linux luffy_boy]# cat requirements.txt
certifi==2018.11.29
chardet==3.0.4
crypto==1.4.1
Django==2.1.4
django-redis==4.10.0
django-rest-framework==0.1.0
djangorestframework==3.9.0
idna==2.8
Naked==0.1.31
pycrypto==2.6.1
pytz==2018.7
PyYAML==3.13
redis==3.0.1
requests==2.21.0
shellescape==3.4.1
urllib3==1.24.1
uWSGI==2.0.17.1
4.安装路飞的依赖文件
(s25_luffy) [root@s25linux luffy_boy]# pip3 install -i https://pypi.douban.com/simple -r requirements.txt
5.测试路飞代码是否能够运行
python3 manage.py runserver 0.0.0.0:8080
6.测试通过之后，配置uwsgi.ini，启动路飞后端，老师的uwsig.ini内容如下
###########################
(s25_luffy) [root@s25linux luffy_boy]# cat uwsgi.ini
[uwsgi]
# Django-related settings
# the base directory (full path)
# 填写crm项目的第一层绝对路径
chdir = /s25luffy/luffy_boy
# Django's wsgi file
# 填写crm项目第二层的相对路径，找到第二层目录下的wsgi.py
# 这里填写的不是路径，是以上一个参数为相对，找到第二层项目目录下的wsgi.py文件
module = luffy_boy.wsgi
# the virtualenv (full path)
# 填写虚拟环境解释器的第一层工作目录
home = /s25luffy/luffy_boy/s25_luffy
# process-related settings
# master
master = true
# maximum number of worker processes
# 代表定义uwsgi运行的多进程数量，官网给出的优化建议是 2*cpu核数+1 ，单核的cpu填写几?
# 如果是单进程，十万个请求，都丢给一个进程去处理
# 3个工作进程，十万个请求，就分给了3个进程去分摊处理
processes = 3
# the socket (use the full path to be safe
# 这里的socket参数，是用于和nginx结合部署的unix-socket参数，这里临时先暂停使用
# 使用此协议运行后台，就无法通过浏览器访问了，协议不一样
socket = 0.0.0.0:9005
# 线上不会用http参数，因为对后端是不安全的，使用socket参数是安全的连接，用nginx反向代理去访问
# 后端程序是运行在防火墙内部，外网是无法直接访问的
# 临时使用http参数，便于我们用浏览器调试访问
#http = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket = 664
# clear environment on exit
vacuum = true
########################################
7.此时给supervisor再添加一个任务，用于管理路飞
vim /etc/supervisord.conf
在最下面，添加如下
[program:s25_luffy]
command=/s25luffy/luffy_boy/s25_luffy/bin/uwsgi --ini /s25luffy/luffy_boy/uwsgi.ini
autostart=true
startsecs=10
autorestart=true
stopasgroup=true
killasgroup=true
8.此时重启supervisord进程，把新的任务，管理路飞也加进去
先杀死所有的supervisor进程吧
pkill -9 supervisor #杀死supervisor进程，用于重启
pkill -9 uwsgi #杀死crm的进程，用于待会重启
9.此时检查2个任务的状态
(s25_luffy) [root@s25linux luffy_boy]# supervisorctl -c /etc/supervisord.conf
again_s25crm STARTING
s25_luffy STARTING
supervisor>
supervisor>
supervisor> status
again_s25crm STARTING
s25_luffy STARTING
supervisor> status
again_s25crm RUNNING pid 69415, uptime 0:00:13
s25_luffy RUNNING pid 69414, uptime 0:00:13
10.此时发现还差一个代理服务器的配置，修改nginx.conf如下
#再添加一个虚拟主机，作用是给路飞后台的反向代理使用
server {
#这里应该填写9000的代理服务器端口
listen 9000;
server_name _;
# nginx的9000代理服务器，接收到任意请求之后，直接转发给后端的uwsgi
location / {
uwsgi_pass 0.0.0.0:9005;
include uwsgi_params;
}
}
11.重启nginx
nginx -s reload
12.登录路飞的账密
alex
alex3714
13.添加python和linux的课程，加入购物车，查看个人中心的购物车，发现还缺少redis数据库的运行
14.安装redis且启动
yum install redis -y
systemctl start redis
15.
此时已经启动了2个项目
今天作业，展示出如下2个页面
测试访问crm是否正常
测试访问路飞是否正常
今日作业
通过用supervisor管理2个项目
1.使用supervisor启动crm项目，完成nginx+crm的部署
访问192.168.178.140 能够登录crm，使用系统
截图展示，supervisor管理crm进程
截图展示，浏览器访问crm系统，查看数据
2.使用supervisor部署路飞学城前后端分离项目，能够登录网站，查看课程列表，添加购物车等操作
截图展示，supervisor管理路飞进程
截图展示路飞的购物车页面，有数据即可
day07
redis学习
五大数据类型，开发必会的技能
老师的博客
https://www.cnblogs.com/pyyu/p/9467279.html
- string，字符串类型
- hash，哈希类型，如同python的dict
- Set，无序集合
- Zset，有序集合
- List，双向队列，向左插入数据，向右插入数据，向左、右，提取数据
redis安全启动与配置文件，以下都是运维相关的操作了
1.redis如何在linux安装呢？
-rpm包安装
-yum自动化安装，在阿里的yum仓库中，有redis的软件包
-源代码编译安装
redis是内存性数据库，断电，数据丢失，进程重启，数据丢失
得配置redis的数据持久化，防止数据丢失
redis支持ms复制，读写分离，防止单点故障，数据丢失
1.yum install redis -y
2.修改redis.conf，更改默认端口，设置密码，开启安全模式等操作
用yum安装的redis，默认配置文件在/etc/redis.conf
vim /etc/redis.conf #打开如下参数即可
# 这里是绑定redis的启动地址，如果你支持远程连接，就改为0.0.0.0
bind 0.0.0.0
#更改端口
port 6500
#设置redis的密码
requirepass haohaio
#默认打开了安全模式
protected-mode yes
#打开一个redis后台运行的参数
daemonize yes
3.启动redis
为什么systemctl start redis无法连接呢？
是因为这个命令默认连接的是6379端口，我们更改了redis端口，因此无法连接了
请使用如下的命令，指定配置文件启动
[root@s25linux opt]# redis-server /etc/redis.conf
#检查redis的进程
[root@s25linux opt]# ps -ef|grep redis
root 6498 1 0 11:42 ? 00:00:00 redis-server 0.0.0.0:6500
4.连接redis服务端，指定ip地址和端口，以及密码连接redis
-p 指定端口
-h 指定ip地址
auth指令，用于密码验证
[root@s25linux opt]# redis-cli -p 6500 -h 192.168.178.143
192.168.178.143:6500>
192.168.178.143:6500>
192.168.178.143:6500>
192.168.178.143:6500>
192.168.178.143:6500> ping
(error) NOAUTH Authentication required.
192.168.178.143:6500>
192.168.178.143:6500> auth haohaio
OK
192.168.178.143:6500>
192.168.178.143:6500> ping
PONG
redis常用命令
keys * 列出redis所有的key
redis数据持久化之RDB机制
向redis中写入一些数据，重启进程，查看数据是否会丢失
1.环境准备，准备一个redis.conf配置文件，不开启数据数据持久化
先杀死所有的redis进程，重新写一个配置文件
[root@s25linux s25redis]# cat no_rdb_redis.conf
bind 0.0.0.0
daemonize yes
2.指定该文件启动
[root@s25linux s25redis]# redis-server no_rdb_redis.conf
[root@s25linux s25redis]# ps -ef|grep redis
root 6698 1 0 11:50 ? 00:00:00 redis-server 0.0.0.0:6379
3.登录数据库，写入数据，然后杀死redis进程，查看数据是否存在
以上的操作，都是为了演示，redis如果不配置持久化，数据会丢失，请看如下的持久化机制
1.配置rdb机制的数据持久化，数据文件是一个看不懂的二进制文件，且配置触发的时间机制
vim s25_rdb_redis.conf ，写入如下内容
daemonize yes #后台运行
port 6379 #端口
logfile /data/6379/redis.log #指定redis的运行日志，存储位置
dir /data/6379 #指定redis的数据文件，存放路径
dbfilename s25_dump.rdb #指定数据持久化的文件名字
bind 127.0.0.1 #指定redis的运行ip地址
#redis触发save指令，用于数据持久化的时间机制
# 900秒之内有1个修改的命令操作，如set .mset,del
save 900 1
# 在300秒内有10个修改类的操作
save 300 10
# 60秒内有10000个修改类的操作
save 60 10000
写入了一个key
set name 很快就下课让大家去吃饭
#快速的执行了10次的修改类的操作
比如 set name hehe
set name1 haha
...
#新浪微博，1秒中内，写入了20w个新的key，因此也就是每分钟，进行一次数据持久化了
2.创建redis的数据文件夹，
mkdir -p /data/6379
3.杀死之前所有的redis，防止扰乱实验
[root@s25linux s25redis]# pkill -9 redis
4.指定配置了rdb的redis配置文件，启动
redis-server s25_rdb_redis.conf
5.如果没有触发redis的持久化时间机制，数据文件是不会生成的，数据重启进程也会丢
6.可以通过编写脚本，让redis手动执行save命令，触发持久化，在redis命令行中，直接输入save即可触发持久化
127.0.0.1:6379> set addr shahe
OK
127.0.0.1:6379>
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379> keys *
1) "age"
2) "addr"
3) "name"
127.0.0.1:6379> save
OK
7.存在了rdb持久化的文件之后，重启redis进程，数据也不会丢了，redis在重启之后，会读取dump.rdb文件中的数据
8.rdb的弊端在于什么，如果没有触发持久化机制，就发生了机器宕机，数据就会丢失了，因此redis有一个更好的aof机制
请看下集分解。。。下午来说aof持久化机制
AOF之持久化机制
把修改类的redis命令操作，记录下来，追加写入到aof文件中，且是我们能够看得懂的日志文件
1.准备一个新的配置文件，里面定义了aof的功能性参数即可使用
vim s25_aof_redis.conf
写入如下内容
daemonize yes
port 6379
logfile /data/6379aof/redis.log
dir /data/6379aof/
appendonly yes #开启aof功能
appendfsync everysec #每秒钟持久化一次
2.创建aof的数据文件夹
mkdir -p /data/6379aof/
3.启动aof的redis的数据库
redis-server s25_aof_redis.conf
4.aof机制的数据库，在首次启动的时候，就会生成aof数据文件了，如下
[root@s25linux 6379aof]# ls
appendonly.aof redis.log
5.登录redis,写入数据
[root@s25linux s25redis]# redis-cli
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set name zhunbeixiakechifan
OK
127.0.0.1:6379> set name2 xinkudajiale
OK
127.0.0.1:6379> keys *
1) "name2"
2) "name"
6.写入的操作，会被记录到aof文件日志中
7.杀死所有的redis进程，且重启
[root@s25linux s25redis]# pkill -9 redis
[root@s25linux s25redis]# redis-server s25_aof_redis.conf
8.redis的aof持久化机制，是在重启的时候，redis重新执行一遍aof文件中的命令，实现数据复现
9.如果该aof日志文件被删除，数据也就无法恢复了
redis数据同步复制
在一台机器上运行2个及以上的redis，是redis支持多实例的功能，基于端口号的不同，就能够运行多个相互独立的redis数据库
什么是多实例
就是机器上运行了多个redis相互独立的进程
互不干扰的独立的数据库
叫做多个redis数据库的实例，基于配置文件区分即可
1.上午的最后一步，演示的是，当我们删除aof文件，或者是rdb，aof文件异常损坏，丢失，数据不也没了吗？
操作笔记
如图是redis的多实例功能，且配置主从同步的图
1.准备好2个redis的配置文件，分别写入如下内容
vim s25-master-redis.conf
port 6379
daemonize yes
pidfile /s25/6379/redis.pid
loglevel notice
logfile "/s25/6379/redis.log"
dbfilename dump.rdb
dir /s25/6379
protected-mode no
2.准备第二个配置文件
vim s25-slave-redis.conf
port 6389
daemonize yes
pidfile /s25/6389/redis.pid
loglevel notice
logfile "/s25/6389/redis.log"
dbfilename dump.rdb
dir /s25/6389
protected-mode no
slaveof 127.0.0.1 6379 #也可直接在配置文件中，定义好复制关系，启动后，立即就会建立复制
3.分别生成2个redis的数据文件夹
mkdir -p /s25/{6379,6389}
4.分别启动2个redis数据库，查看他们的身份复制关系
[root@s25linux s25redis]# redis-server s25-master-redis.conf
[root@s25linux s25redis]#
[root@s25linux s25redis]#
[root@s25linux s25redis]# redis-server s25-slave-redis.conf
5.分别检查他们的进程，以及复制关系
[root@s25linux s25redis]# redis-cli -p 6379 info replication
[root@s25linux s25redis]# redis-cli -p 6389 info replication
通过一条命令，配置他们的复制关系，注意，这个命令只是临时配置redis的复制关系，想要永久修改，还得修改配置文件
redis-cli -p 6389 slaveof 127.0.0.1 6379
6.此时6379已然是主库，6389已然是从库
此时可以向6379中写入数据，能够同步到6389中
6389是一个只读的数据库，无法写入数据
一主多从的形式，以及主从复制故障切换
1.再创建一个配置文件，port是6399，且加入到一主一从的复制关系中去
vim s25-salve2-redis.conf
port 6399
daemonize yes
pidfile /s25/6399/redis.pid
loglevel notice
logfile "/s25/6399/redis.log"
dbfilename dump.rdb
dir /s25/6399
protected-mode no
slaveof 127.0.0.1 6379
2.创建数据文件夹
mkdir -p /s25/6399
3.启动6399的数据库，查看他的身份复制关系
[root@s25linux s25redis]# redis-cli -p 6399 info replication
此时问题来了，故障模拟
1.环境准备，准备3个redis的数据库实例，分别是 6379、6389、6399，配置好一主两从的关系
[root@s25linux s25redis]# ps -ef|grep redis
root 11294 1 0 15:19 ? 00:00:01 redis-server *:6379
root 11310 1 0 15:19 ? 00:00:01 redis-server *:6389
root 11620 1 0 15:33 ? 00:00:00 redis-server *:6399
分别查看复制关系
[root@s25linux s25redis]# redis-cli -p 6379 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6389,state=online,offset=1883,lag=1
slave1:ip=127.0.0.1,port=6399,state=online,offset=1883,lag=1
2.此时直接干掉主库即可
kill 6379的pid即可
3.此时留下2个孤零零的从库，没有了主人，还没发写入数据，很难受
4.此时一位从库，不乐意了，翻身农奴做主人，去掉自己的从库身份，没有这个从库的枷锁，我就是我自己的主人
[root@s25linux s25redis]# redis-cli -p 6399 slaveof no one
5.此时6399已然是主库了，修改6389的复制信息，改为6399即可
[root@s25linux s25redis]# redis-cli -p 6389 slaveof 127.0.0.1 6399
OK
6.此时检查他们的复制关系
[root@s25linux s25redis]# redis-cli -p 6389 info replication
[root@s25linux s25redis]# redis-cli -p 6399 info replication
7.此时可以向主库6399写入数据，6389查看数据即可
主库不挂，从库挂掉的场景
从库挂掉，无所谓，重新再建立一个从库，加入主从复制即可，。，。
你会发现，如此的手动切换复制关系，其实是很难受的，如果在夜里凌晨四点，redis主库突然挂了，你该怎么办？你媳妇愿意让你起来干活吗？
因此你该咋办？是不是得学点别的技术？你希望有什么东西能帮你不？
- 有钱，你搞一个贾维斯
- 希望有一个人，能24h帮你盯着这个主从复制，发现主库宕机之后，自动的帮你进行主从切换
redis高可用哨兵
redis哨兵的工作原理：
配置好redis的哨兵进程，一般都是使用3个哨兵（保安）
哨兵的作用是盯着redis主库，不断询问它是否存活，如果超过30s（设置的时间阈值）都没有回应，3个哨兵会判断主库宕机，谈话进行投票机制，因为3个哨兵，要自动的去选择从库为新的主库，每个哨兵的意见可能不一样
因此引出投票机制，少数服从多数
当多个哨兵达成一致，选择某一个从库阶段，自动的修改他们的配置文件，切换新的主库
此时如果宕机的主库，恢复后，哨兵也会自动将其加入集群，且自动分配为新的从库
这一些都是自动化，无需人为干预，贼牛屁
哨兵集群的配置
1.准备3个主从复制的redis实例
明天见~~~~感谢倾听
明天的课程内容
- docker容器技术
- redis哨兵搭建
- redis-cluster集群搭建
day09
上节课补充
昨天的作业完成情况并不好，近10个同学没交
有几个同学码云的评论，仅仅完成了1-2道题
它不仅仅是个作业，也是一个任务，执行力是一个人很重要的表现....
不忘初心、方得始终！
redis-sentinel
1.准备3个redis节点，1主2从的redis集群
redis支持多实例-------基于多个配置文件，运行处多个redis相互独立的进程
s25-redis-6379.conf -----主
port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/var/redis/data/"
s25-redis-6380.conf------从1
port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/var/redis/data/"
slaveof 127.0.0.1 6379
s25-redis-6381.conf-----从2
port 6381
daemonize yes
logfile "6381.log"
dbfilename "dump-6381.rdb"
dir "/var/redis/data/"
slaveof 127.0.0.1 6379
#查看3个配置文件，准备分别启动该进程
[root@s25linux s25sentinel]# ls
s25-redis-6379.conf s25-redis-6380.conf s25-redis-6381.conf
#分别启动3个进程后，检查进程情况
[root@s25linux s25sentinel]# redis-server s25-redis-6379.conf
[root@s25linux s25sentinel]# redis-server s25-redis-6380.conf
[root@s25linux s25sentinel]# redis-server s25-redis-6381.conf
[root@s25linux s25sentinel]# ps -ef|grep redis
root 20413 1 0 08:45 ? 00:00:00 redis-server *:6379
root 20417 1 0 08:45 ? 00:00:00 redis-server *:6380
root 20422 1 0 08:45 ? 00:00:00 redis-server *:6381
#确认3个库的主从关系
[root@s25linux s25sentinel]# redis-cli -p 6379 info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6380,state=online,offset=183,lag=1
slave1:ip=127.0.0.1,port=6381,state=online,offset=183,lag=1
1主2从的环境搭建好了，准备招来3个值班的也就是，redis的哨兵
1.分别准备3个哨兵的配置文件，修改如下，三个哨兵的配置文件，仅仅是端口号的不同
vim s25-sentinel-26379.conf
port 26379
dir /var/redis/data/
logfile "26379.log"
：
s25-sentinel-26380.conf
port 26380
dir /var/redis/data/
logfile "26380.log"
sentinel monitor s25msredis 127.0.0.1 6379 2
sentinel down-after-milliseconds s25msredis 30000
sentinel parallel-syncs s25msredis 1
sentinel failover-timeout s25msredis 180000
daemonize yes
s25-sentinel-26381.conf
port 26381
dir /var/redis/data/
logfile "26381.log"
sentinel monitor s25msredis 127.0.0.1 6379 2
sentinel down-after-milliseconds s25msredis 30000
sentinel parallel-syncs s25msredis 1
sentinel failover-timeout s25msredis 180000
daemonize yes
#分别启动3个哨兵进程，以及查看进程信息
[root@s25linux s25sentinel]# redis-sentinel s25-sentinel-26379.conf
[root@s25linux s25sentinel]# redis-sentinel s25-sentinel-26380.conf
[root@s25linux s25sentinel]# redis-sentinel s25-sentinel-26381.conf
[root@s25linux s25sentinel]# ps -ef|grep redis
root 20413 1 0 08:45 ? 00:00:00 redis-server *:6379
root 20417 1 0 08:45 ? 00:00:00 redis-server *:6380
root 20422 1 0 08:45 ? 00:00:00 redis-server *:6381
root 20614 1 0 08:55 ? 00:00:00 redis-sentinel *:26379 [sentinel]
root 20618 1 0 08:55 ? 00:00:00 redis-sentinel *:26380 [sentinel]
root 20622 1 0 08:55 ? 00:00:00 redis-sentinel *:26381 [sentinel]
#检查redis哨兵的配置文件，以及哨兵的状态
[root@s25linux s25sentinel]# redis-cli -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=s25msredis,status=ok,address=127.0.0.1:6379,slaves=2,sentinels=3
在哨兵搭建好了之后，模拟干掉主库，然后等待主从的一个自动化切换
1.检查6379的进程，杀死后，哨兵能够自动的，进行投票选举，剩下来的一个slave为新的master，然后重新分配主从关系
2.故障的修复，修复6379这个redis数据库，且检查它的一个复制关系
6379数据库会重新假如到主从复制，且变为一个新的从库
3.如果你想恢复他们的主从关系，全部kill掉，重新启动，默认就会以配置文件分配主从关系了
redis-cluster搭建
1.准备好6匹马儿，也就是6个redis节点，也就是6个配置文件，redis集群节点最少是使用6个
这6个配置文件，仅仅是端口号的不同而已
这6个配置文件，仅仅是端口号的不同而已
这6个配置文件，仅仅是端口号的不同而已
s25-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 #redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。 因此生产环境一般为no
s25-redis-7001.conf
s25-redis-7002.conf
s25-redis-7003.conf
s25-redis-7004.conf
s25-redis-7005.conf
#生成数据文件夹
mkdir -p "/opt/redis/data"
#分别启动6个redis节点，且检查进程
[root@s25linux s25rediscluster]# redis-server s25-redis-7000.conf
[root@s25linux s25rediscluster]# redis-server s25-redis-7001.conf
[root@s25linux s25rediscluster]# redis-server s25-redis-7002.conf
[root@s25linux s25rediscluster]# redis-server s25-redis-7003.conf
[root@s25linux s25rediscluster]# redis-server s25-redis-7004.conf
[root@s25linux s25rediscluster]# redis-server s25-redis-7005.conf
#此时你尝试着写入数据，看一看是否能写进去，不能写入数据
我们仅仅是启动了6个redis节点，准备好了6匹马儿，马儿身上的框还没分配，你想
此时准备好ruby的环境，用于一键创建redis集群，给马儿分配框，给redis节点分配slot槽位，用于写入数据
1.直接yum安装ruby解释器ruby和python一样是一个解释性编程语言，日本大神开发的
ruby=====python gem====pip3 gem是ruby的包管理工具
ruby=====python gem====pip3 gem是ruby的包管理工具
yum install ruby -y
2.检查ruby和gem的环境
[root@s25linux s25rediscluster]# ruby -v
ruby 2.0.0p648 (2015-12-16) [x86_64-linux]
[root@s25linux s25rediscluster]# gem -v
2.0.14.1
3.下载ruby操作redis的模块，用于创建集群
wget http://rubygems.org/downloads/redis-3.3.0.gem
4.用gem安装此模块,ruby就可以操作redis数据库了
gem install -l redis-3.3.0.gem #就如同python的 pip3 install xxxx，不难理解
5.搜索ruby创建redis集群的脚本
redis-trib.rb 如何知道它的绝对路径？
which 是搜索PATH环境变量中的命令的绝对路径！
find 才是搜索系统上的文件路径！！
find / -name "redis-trib.rb" #默认会在redis数据库的编译安装路径下
6.一键创建集群，且自动分配槽位，可以写入数据了
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
7.进入集群写入数据，查看数据重定向
以上由于redis版本过低，且redis官网无法打开，下载新版redis，实验只能终止
docker学习
本地开发环境--快速开发新功能---django2---等等新的模块
测试环境---测试代码
预生产环境---和线上服务器环境一模一样
线上环境服务器---部署代码
整个环境部署的问题，非常棘手，因此引入了容器技术，唰的一下，全部解决了
解决环境迁移的难题
1.利用虚拟机的模板克隆功能，将整个机器的环境复制一份，再丢给第二个机器去使用
2.最好是使用docker去部署环境
docker的生命周期概念
- 镜像，是一个系统的只读模板，例如一个微型的centos系统镜像
- 容器，容器进程，应用程序以后封装在容器中去运行，相互隔离
- 仓库，存储镜像的一个仓库地址，便于和他人共享镜像文件的一个地方
基于镜像运行处容器
基于一个镜像，可以运行处N多个容器实例
以python的面向对象去理解的话
docker的镜像---------理解为python的 class
docker的容器-------理解为class的实例化对象
class Stu():
def __init__(self):
self.age=18
self.height=180
self.weight=280
老王=Stu()
小李=Stu()
小张=Stu()
问，老王，小李，小张之间有什么相同性吗？ 这3个对象，都有相同的Init里面的实例化属性
基于如上的概念理解，基于同一个镜像文件，运行出的容器实例，其容器内的环境，也是一模一样的！理解一下
安装docker，使用docker
使用阿里云的yum源，可以直接安装docker软件，阿里云的docker软件版本可能较低，如果要下载新的，去docker官网找
1.yum install docker -y
2.配置docker的镜像加速器，加速系统镜像的下载，默认是去国外下载，比较慢
能够加速下载你所需要的各种镜像，来自如如下提供的2个镜像站点
比如你想快速的使用tornado模块去开发一些东西
-编译安装python3
-安装tornado模块及依赖关系
-加上你的代码才能够运行
当你有了docker技术
docker search tornado #直接搜索和tornado有关的镜像，是其他人制作好的镜像
docker pull tornado #直接下载该镜像，和代码结合使用，docker解决了，省去了你配置环境的一些步骤
vim /etc/docker/daemon.json #修改docker的配置文件，修改docker镜像的下载地址，在国内下载比较快
{
"registry-mirrors": [
"https://dockerhub.azk8s.cn",
"https://hub-mirror.c.163.com"
]
}
3.重启docker，运行docker
systemctl restart docker
4.获取一个centos的基础镜像，docker的系统镜像，非常小， centos只有200M左右
docker pull centos
学习docker容器、镜像的增删改查命令
增
1.从dockerhub 仓库中获取docker的镜像，从github获取代码一个道理
docker pull centos #去docker仓库中寻找centos系统镜像
docker pull ubuntu #获取ubuntu镜像
2.获取一个hello-world进程
docker pull hello-world
3.获取一个ubuntu镜像
docker pull ubuntu
4.搜索相关的镜像
docker search python3
#比如你想用nginx，又不想修改宿主机的一个软件环境，直接用docker安装
docker search nginx
docker pull nginx
docker run nginx #nginx服务器就能够运行在容器中，然后和宿主机有一个端口映射，就可以访问了
删
1.删除本地镜像文件
docker rmi 镜像id
docker rmi fce #删除镜像id的前3位即可，必须要先删除有相关依赖的容器进程记录
2.删除容器记录的命令
docker rm 容器id前3位
3.批量清空无用的docker容器记录，容器记录非常容易创建docke run
#批量删除挂掉的容器记录
docker rm `docker ps -aq` # 把docker容器记录的id号，保存在反引号中，丢给docker rm实现批量删除
4.批量删除镜像
docker rmi `docker iamges -aq`
5.批量停止容器
docker stop `docker ps -aq`
docker start 容器id #启动暂停的容器
docker stop 容器id #暂停一个容器
docker restart 容器id #重启容器
改
1.运行第一个docker的容器实例，运行镜像文件，产生容器进程
docker run 镜像文件的名字即可
docker run centos #运行centos基础镜像，如果docker容器中没有在后台运行的进程，容器会直接挂掉
#如果你发现你的容器没有启动成功，说明容器内部出错了，程序没有运行
2.运行一个hello world容器进程
docker run hello-world
3.docker run指令还有一个功能是，当镜像不存在的时候，会自动去下载该进程
此时老师的电脑，本地没有hello-world镜像了
docker run hello-world #有2个功能，下载镜像，执行镜像
4.交互式的运行一个存活的docker容器，centos
# -it参数 -i 是交互式的命令操作 -t开启一个终端 /bin/bash 指定shell解释器
# 容器空间内，有自己的文件系统
docker run -it centos /bin/bash #运行centos镜像，且进入容器内
[root@s25linux ~]# docker run -it centos /bin/bash #进入容器后，容器空间内是以容器id命名的
[root@fc760671d074 /]#
5.运行出一个活着的容器，在后台不断执行程序的容器
# docker run 运行镜像文件
# -d 是让容器后台运行
# -c 指定一段shell代码
# 运行centos镜像，生成容器实例，且有一段shell代码，在后台不断运行，死循环打印一句话，每秒钟打印一次
docker run -d centos /bin/sh -c "while true;do echo s25的靓仔们辛苦了学习linux; sleep 1;done"
6.运行docker容器，且指定名字，便于管理
docker run --name "指定容器的运行名字“ -d centos /bin/sh -c "while true;do echo s25的靓仔们辛苦了学习linux; sleep 1;done"
7.进入一个正在运行的容器空间，进入一个线上正在运行的容器程序，修改其内部的资料
docker exec -it 容器id /bin/bash
8.如何进入容器空间内，修改容器内的环境，以及代码等内容，修改软件等操作，且提交镜像，发送给其他人
8.1 进入容器空间内，安装一个vim或是python3等步骤
docker run -it centos /bin/bash
yum install vim -y
8.2 安装好vim后，退出容器空间
exit
8.3 提交该容器，生成新的镜像文件
docker commit 5b28d8c88794 s25-centos-vim
9.导出你的docker镜像，可以发送给同事，或是其他人使用
docker save 镜像id > 镜像的压缩文件
#官方文档解释的是，docker save用的是tar命令压缩，应该是没有其他压缩格式的
[root@s25linux ~]# docker save 45d7f887125d > /opt/s25-centos-vim.tar.gz
#你可以删掉本地的镜像，然后重新导入该压缩文件，模拟发送给同事的操作
10.如何进行docker镜像导入
比如小李运维同志，他收到了该docker镜像压缩文件，在他的机器上导入该进项
docker load < /opt/s25-centos-vim.tar.gz
首次导入该进项的时候，发现丢失了镜像tag标签，重新赋予一个即可
docker tag 45d7f887125d s25-new-centos-vim
11.如何在docker内，运行一个python web的程序，需要用到端口映射知识~~~~
# -d 后台运行
# -P 大写的P参数，作用是随机的端口映射
# training/webapp 是镜像的名字，默认没有会去在线下载
# python app.py 代表启动容器后，让容器执行的命令是它
# 因此这个命令作用是，启动一个webapp镜像，且在容器中执行 python app.py
# -p 6000:5000 访问宿主机的6000，就是访问容器的5000了
docker run --name "s25webdocker" -d -p 6000:5000 training/webapp python app.py
12.进入该webapp的容器，查看里面的内容
docker exec -it 容器id /bin/bash #进入容器内，可以进行相应的修改操作
docker restart 容器id #重启该容器，重新读取代码，即可生效
对于后端开发的程序员，只需要掌握Docker的容器，镜像，仓库的增删改查命令即可
查
1.查看本地机器，所有的镜像文件内容
docker images
2.查看docker正在运行的进程
docker ps
3.查看所有运行，以及挂掉的容器进程
docker ps -a
4.查看容器内的运行日志
docker logs 容器id
docker logs -f 容器id #实时刷新容器内的日志，例如检测nginx等日志信息
5.查看容器内的端口转发情况
docker port 容器id #查看容器的端口转发
[root@s25linux ~]# docker port 615
5000/tcp -> 0.0.0.0:6000
dockerfile
手写一个dockerfile，运行出python的应用
腾讯课堂的极速版讲课，我会发给你们一个课堂的连接，即可观看~~~~休息20分钟
4：30继续开讲
愿意听就好~~谢谢，休息一会
细水长流，有任何linux的疑问，都可以来问我，互相学习，进步
dockerfile常用指令学习
# FROM 指令表示，告诉该dockerfile以哪个镜像为基础
# 比如你的技术老大，要求你们程序运行在ubuntu中
# FROM ubuntu
# FROM centos
FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
FROM centos #使用base image
FROM ubuntu:14.04 #带有tag的base image
#LABEL标签，定义变量，定义坐着信息等
LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
LABEL maintainer=“yc_uuu@163.com"
#RUN是一个完成指令，你可以用它在docker中执行任意的命令
# RUN就是告诉容器要做哪些配置
# 用RUN指令告诉dockerfile他该去做什么事
RUN mkdir /s25牛批
RUN cd /s25牛批
RUN cd
RUN pwd #会输出什么？ 因此在容器中会输出，用户家目录
#对于复杂的RUN命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
# 要修改centos基础镜像的环境问题
RUN yum update && yum install -y vim \
Python-dev #反斜线换行
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME”
WORKDIR /root #相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
WORKDIR /test #如果没有就自动创建
WORKDIR demo #再进入demo文件夹
RUN pwd #打印结果应该是/test/demo
#案例
WORKDIR /s25很棒
WORKDIR 我们要说goodbay了
RUN pwd #会输出什么？ /s25很棒/我们要说goodbay了 此时进入了2层目录
# ADD指令用于添加宿主机的文件，放入到容器空间内
# 宿主机有自己的文件系统，文件夹，文件，目录等
# 容器内也有一套自己的文件系统，独立的文件信息
# 把宿主机的代码，拷贝到容器内
# ADD还有解压缩的功能，这是一个坑，需要注意
ADD and COPY
ADD hello.txt /opt #吧宿主机的hello.txt 拷贝到容器内的/opt目录下
ADD test.tar.gz /opt /opt/test
RUN tar -zxvf test.tar.gz #直接报错，文件不存在 ，因为上一步，ADD指令已经对tar.gz压缩包解压缩了
WORKDIR /root
ADD hello test/ #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
COPY hello test/ #等同于上述ADD效果
# dockerfile，用于从宿主机拷贝文件，到容器内有2个指令一个ADD，一个COPY，COPY仅仅就是拷贝，尽量用它
ADD与COPY
- 优先使用COPY命令
-ADD除了COPY功能还有解压功能
#添加远程文件/目录使用curl或wget
ENV #环境变量，尽可能使用ENV增加可维护性
ENV MYSQL_VERSION 8.0
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
RUN yum install -y mysql-server=“${MYSQL_VERSION}”
dockfile实战，写一个flask容器脚本
构建镜像的步骤
1.准备好一个flask代码，检查需要哪些依赖步骤
[root@s25linux s25docker]# cat s25_flask.py
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
return "linux就即将结束了，祝大家，找到好工作，有linux问题呢，尽量和我来沟通，互相学习"
if __name__=="__main__":
app.run(host='0.0.0.0',port=8080)
2.在宿主机环境检查如何能够运行该脚本
发现需要安装flask模块
pip3 install -i https://pypi.douban.com/simple flask
3.编写dockerfile脚本，注意名字必须是 大写Dockerfile
touch Dockerfile ，写入如下的内容
FROM python #指定镜像，dockerhub提供好的python镜像，已经安装好了python3，很好用
RUN pip3 install -i https://pypi.douban.com/simple flask #在容器内安装flask模块
ADD s25_flask.py /opt #把宿主机的代码，拷贝到容器的/opt目录下
WORKDIR /opt #容器内进行目录切换
EXPOSE 8080 #打开容器的8080端口，用于和宿主机进行映射
CMD ["python3","s25_flask.py"] #在容器启动后，内部自动执行的命令是什么
4.检查准备的脚本代码，以及Dockerfile文件
[root@s25linux s25docker]# ls
Dockerfile s25_flask.py
5.构建该dockerfile，生成镜像
[root@s25linux s25docker]# docker build .
6.检查docker的镜像，是否生成
docker images
#可以修改一下镜像的标签
[root@s25linux s25docker]# docker tag a66 s25-flask
7.运行该镜像文件，查看是否能够运行容器内的flask
docker run -d -p 8000:8080 a66
8.访问宿主机端口，查看容器内的应用
curl 127.0.0.1:8000
9.可以修改容器内的代码，重启容器
docker exec -it 88a5 /bin/bash
修改容器内的代码
sed -i "s/linux就即将结束了，祝大家，找到好工作，有linux问题呢，尽量和我来沟通，互相学习/linux课程结束，再回！朋友们/" s25_flask.py
10.重启容器
docker restart 88a
11.再次访问容器内应用，查看更新的代码内容
curl 127.0.0.1:8000
dockerhub仓库
dockerhub仓库就是和github一样的概念
github---托管程序员的代码
dockerhub----托管程序员编写的docker镜像
1.docker提供了一个类似于github的仓库dockerhub,
网址https://hub.docker.com/需要注册使用
2.注册docker id后，在linux中登录dockerhub，会提示让你输入账号密码，正确登录之后，本台机器就和dockerhub绑定账号了，你的镜像推送，就能够推送到，该账户的dockerhub中
docker login
2.1准备镜像推送
注意要保证image的tag是dockerhub账户名，如果镜像名字不对，需要改一下tag
docker tag 镜像id dockerhub的账号/centos-vim
语法是： docker tag 仓库名 yuchao163/仓库名
3.推送docker image到dockerhub，好比你准备git push 推送代码一样
docker push dockerhub账号/centos-vim
4.在dockerhub中检查镜像,查看个人账户中的镜像文件
https://hub.docker.com/
5.删除本地镜像，测试下载pull 镜像文件
docker pull yuchao163/centos-vim
yaml配置文件
你用过哪些格式的配置文件？
不同的配置文件，遵循的语法也不一样
- json------
- Conf----nginx.conf ,my.cnf
- ini ------uwsgi.ini
- Xml----xml格式的配置文件
- yaml----新式配置文件，用在docker、salt、k8s等配置文件中,遵循python的缩进语法
yaml
语法规则
大小写敏感
使用缩进表示层级关系
缩进时禁止tab键，只能空格
缩进的空格数不重要，相同层级的元素左侧对其即可
# 表示注释行
yaml支持的数据结构
对象： 键值对，也称作映射 mapping 哈希hashes 字典 dict 冒号表示 key: value key冒号后必须有
数组： 一组按次序排列的值，又称为序列sequence 列表list 短横线 - list1
纯量： 单个不可再分的值
对象：键值对
python
python的字典套字典，数据结构表示如下
{
"s25":{
"男同学":["宝元","太白","马jj"],
"女同学":["景女神","alex"]
}
}
如何用yaml表示上述数据结构呢？
在线yaml解析
https://www.bejson.com/validators/yaml_editor/
"s25":
"男同学":
- "宝元"
- "太白"
- "马jj"
"女同学":
- "景女神"
- "alex"
浙公网安备 33010602011771号