Liunx笔记

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 [email protected]

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 [email protected]

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 [email protected]:/opt/
另一台机器查看
ls /opt/

传递文件夹
scp -r -v chenwei1111 [email protected]:/home/
远程下载文件夹
scp -r [email protected]:/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 [email protected]:/opt/
25.将服务器2的/opt/test.py拷贝到服务器1的/home目录下
scp -r [email protected]:/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 [email protected]:/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 写入

啊哈哈哈哈哈哈,你来打我呀

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

我是高哥,我喜欢新垣结衣

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直接处理

正向代理
代理的是客户端
通过的身份去请求国外的资源(服务器其你去-->代理服务器端-->国外服务器)
反向代理
代理的是服务端
服务器请求-->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 "

我是伟华

"
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 "

我是琛琛

"
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"
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
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这个文件，设置属性，为可执行

 

转载于:https://www.cnblogs.com/chenyibai/p/10170840.html