Linux

絕對和相對路徑

絕對路徑: 以根目錄為起點的路徑

相對路徑: 不是以/這個根目錄為源頭劃分的

xshell快捷鍵:

• ctrl + l 清屏

• ctrl + d 退出登錄

• ctrl + shift + r 快速重新連接

• win + 空格 切換輸入法

用戶篇:

# 更改用戶名
hostnamectl	set-hostname	<新的用戶名>
# 登出
logout

零碎Note:

linux的變數賦值不得有空格, 有空格就識別為引數了, example:

name = "zzy"#錯誤
name="zzy"#正確

更改主機名的命令

hostnamectl set-hostname 你想要的主機名
#重新登陸永久生效

元件

LD_LIBRARY_PATH是Linux環境變數名，該環境變數主要用于指定查找共享庫（元件）時除了默認路徑之外的其他路徑

尋找最近的命令

#自下而上尋找最近的命令執行
!ps 代表執行時間最近的一條ps命令

poweroff 關機

reboot 重啟

vim /etc/motd 編輯開機提示語

目錄結構:

命令:

change directory
cd命令:更改目錄的意思

. 當前作業的目錄
.. 上一級作業的目錄
-上一次作業的目錄
~ 當前系統登錄的用戶家目錄

list
ls命令:列出檔案物件	
	-a:顯示出所有內容以及隱藏的檔案(ALL)
	-l:列出檔案詳細資訊
	-h:與人類可閱讀的方式輸出檔案大小
	--full-time:以完整的時間格式輸出
	-t:根據最后修改時間排序檔案
	-F:在不同檔案結尾,輸出不同的特殊符號
		以/結尾的就是檔案夾
		以*結尾的就是可執行檔案
		以@結尾的就是軟連接,快捷方式
		普通檔案型別,結尾什么都沒有
	-d:顯示檔案夾本身資訊,不輸出其中的內容
	-r:reverse 逆向排序
	-S:針對檔案大小進行排序
	-i:顯示檔案的inode資訊(檔案身份證號碼,存盤了檔案的元資訊[檔案的大小,位置,權限...])
	
	擴展:
		ll == ls -l
		
	
linux隱藏檔案, 以.開頭例如:
.secret

pwd命令: print word directory 列印作業目錄的意思,會輸出當前所處的一個絕對路徑

su:用戶切換命令
語法
su - 用戶名 # 完全的環境變數用戶切換	

logout: # 退出當前用戶

新建目錄

makedir
make directory # 創建檔案夾
語法:
mkdir 檔案夾名
	引數用法:
	-p:遞回創建檔案夾
	例如:mkdir - p /zzy/zzys/zzyss	

移動目錄

'move 
    mv zzy ym # 表示把zzy重命名為ym
    mv ./zzy/ym ./ # 表示把當前目錄下zzy里面的ym移動到當前目錄(./)

新建檔案

touch命令
touch zzy.txt zzy.exe
touch alex{1..100}  創建多個檔案方式
	-t:修改檔案的時間 示例:[touch -t zzy.txt 20220606]

man 手冊,解釋linux的命令如何使用
man
ls man

1.復制普通檔案

cp zzy.txt
'示例:
	cp mjj.txt ./oldboy/ #復制放入其他檔案夾,保留源檔案名
	cp mjj.txt ./oldboy/mjj2.txt #復制檔案并放入其他檔案夾,且改名
	cp mjj.exe mjj.png ./mjj/ #復制多個檔案到指定檔案夾中
	cp -r mjj mjj2 #復制整個檔案夾(遞回賦值)

2.linux查看ip的方式

ifconfig # 查看網卡資訊
ip addr show # 顯示出ip網卡的資訊 

3.linux登錄之后的命令提示符

[root@localhost ~]#
當前系統登陸的用戶名 root
@ 占位符
localhost 當前主機名
~  當前你所在的路徑
# 超級用戶的身份提示符
$ 普通用戶的身份提示符

4.創建linux普通用戶

useradd zzy <enter>
# 創建的用戶資訊會放在 /etc/passwd這個檔案下
passwd zzy #修改用戶密碼

5.vim編輯器, 文本編輯器

vi #如同win的記事本
vim #如同notepad++ 支持編程的編輯器

6.vim使用流程:

? 1.vim file_name // 此時進入了一個命令模式, 等待你輸入相關的命令

? 2.如果你要編輯,就輸入字母 i , 代表插入, 編輯(insert)

? 3.寫完代碼后, 退出編輯模式, 按 鍵

? 4.此時回到了命令名, 輸入冒號 : 進入底線命令模式, 輸入 :wq (w:寫入)(q:退出)

:wq! 強制寫入文本且退出vim

:q 不寫入直接強制退出

:w! 只保存寫入, 不退出

echo "zzy" # 向命令列輸出一條訊息

7.linux命令語法格式

linux命令 空格 引數(可有可無) 空格 你要操作的物件

linux引數的作用, 就是更好的服務于開發人員, 顯示的更友好

ls -a  #顯示全部檔案, 包括隱藏檔案
ls -la #以串列形式詳細輸出檔案資訊

8.遞回創建檔案夾資訊

mkdir --help
man mkdir
中文man手冊: 'http://linux.51yip.com'
mkdir -p
--------需求:創建s19檔案夾, 下級有男同學, 女同學, 且女同學有個girl
mkdir -p /tmp/s19/{nantongxue,nvtongxue/girl}

9.linux安裝tree命令

yum install terr # linux-包管理器

10.linux特殊符號的含義

~ 用戶家目錄
- 上一次的作業目錄
. 當前目錄
.. 上一級目錄
./ 當前作業目錄
> 重定向覆寫輸出符號   w-模式
	--example: echo "zzy" > zzy.txt
	--解釋:等于寫入zzy這句話到zzy.txt檔案中, 如果zzy不存在則創建這個檔案, 等同于py中的w模式
>> 重定向追加輸出符號  a-模式
	--example: echo "zzy" >> zzy.txt
	--解釋:等于追加zzy這句話到zzy.txt檔案中, 不會覆寫之前的內容
<< 重定向追加寫入符號(EOF->End Of File)
	--example: cat >>shi.txt<<EOF
			  >#!coding:utf-8
			  >print('hello world')
			  >EOF
	--解釋:EOF一般會配合cat能夠多行文本輸出, 第一行為命令, 2,3行為輸入的文本, 最后EOF代表結束.

cat命令-文本

cat -n /etc/passwd # 查看文本并顯示行號

11.more less

用于查看很大的文本, cat讀取檔案, 是一次性讀取, 非常占記憶體, 用于讀取小文本

more zzy.txt # 分頁形式查看文本檔案, 每次按下<enter>相當于下一頁

12.linux下的搜索命令

`語法:
	find 從哪找 -name 你要找的檔案名
`引數:
	-name 指定檔案名字
	-type 自定檔案型別	f 文本型別	d 檔案夾型別
`example:
	find / -name heeh.txt # 全域搜索
	find /zzy1997 heeh.txt # 區域搜索
`解釋:
	可以從根目錄尋找, 也可以從目標檔案的上面的任何一級目錄尋找
`進階1: 
	找出zzy1997目錄下的所有txt檔案
	find /zzy1997 -name *.txt # 通配符
`進階2:
	找出zzy1997目錄下的所有python相關的檔案資訊
	find /zzy1997 -name
`進階3:
	找出zzy1997目錄下的與python相關的檔案, 目錄
	find ./ python -type d -name python*  #找目錄
	find ./ python -type f -name python* #找檔案
`查看命令的歷史記錄:
	history

13.linux管道符的用法

`語法:

	第一條命令 | 第二條命令

`用于:

	常用于查看linux行程資訊

	查看linux埠資訊
`查看行程資訊:
	ps -ef | grep python
`查看linux埠資訊:
	netstat -tunlp | grep 3306  #確認mysql是否啟動了3306埠
	netstat -tunlp | grep 8000 #驗證django是否正常啟動
	
	`ip: 
		表示計算機在網路中地址的號碼 0~255 ip范圍 192.168.16.37 192.168.16.xx 這是大家的windows地址
		
	`port: 
		表示應用服務的埠
		80 http web服務埠
		443 https 加密的http
		3306 mysql
		8000 django
		22 ssh協議用的埠
		...

#STDOUT:標準輸出

#STDIN:標準輸入

14.過濾字串命令, 過濾文本資訊

語法:
	grep	引數	你要過濾的字串	你要操作的檔案
引數:
	-i 忽略大小寫
	-v 是反轉搜索結果
題目:
	過濾調settings.py中無用的資訊(空白行, 注釋行)
	grep -v "^#" settings.py | grep -v "^$" 
	注意: $是null的意思

15.從檔案的起始和結尾閱覽內容

語法:
	head -5 <file_name> # 看檔案的前5行
	tail -5 <file_name> # 看檔案的后5行
攜帶引數:
	tail -f <file_name> # 實時監測檔案資訊(flush)

16.運維開發的職責

后端開發, crm開發, 面向的是誰, 你的產品, 面向人類

運維開發做什么事? 運維+開發, 面向的是機器

? 監控平臺開發, 主流監控軟體 zabbix, nagios, 監控軟體, 監控服務器狀態

? cmdb資產平臺開發

? 運維堡壘機開發, 保護服務器安全

? 容器管理平臺, 如: docker容器技術

17.別名alias

前言:
	如何做到當你輸入rm, 就提示用戶, 你個大傻x, 求你別用rm了.
語法:
	alias # 顯示各種命令的詳情
	alias rm="remove" # 把rm命令的名字變為remove
	alias rm="echo 哈哈哈" #把rm命令的-i提示語變成->哈哈哈
取消別名:
	unalias rm # 取消rm的別名設定
	alias rm="rm -i" #或者重新賦值回之前默認的名稱
	

18.遠程傳輸命令

可以在兩臺linux之間互相傳遞檔案

語法:
	scp <你想傳輸的內容> <你想傳到的地方> # 上傳
	scp <你想要的內容> <存放的目錄> # 下載
	可選引數:
		scp <arg>
		-r 遞回復制整個目錄
		-v 詳細方式輸出
		-q 不顯示傳輸進度條
		-c 允許壓縮
example:
	scp word.txt [email protected]:/tmp #上傳
	scp [email protected]:/tmp/word.txt /opt #下載

	

19.如何統計/var/log檔案夾大小(查看檔案夾大小)

方式1:
	ls -lh #詳實的顯示當前檔案資訊,和大小單位
方式2:
	du 命令
	-h 顯示 kb mg gb 單位
	-s 顯示合計大小
example:
	du -sh /var/log # 顯示var/log檔案夾合計大小并帶單位顯示

20.linux的任務管理器

top

21.給檔案加鎖 解鎖

chattr +a 檔案名 #給檔案加鎖
lsattr 檔案 # 查看檔案隱藏屬性

22.linux的時間同步

date #查看當前系統時間
ntpdate -u ntp.aliyun.com #和阿里云的時間服務器同步(-u: update)

23.wget命令

```web get在線下載一個資源
	wget url #下載資源到本地
	'遞回深層
	wget -r -p http:luffycity.com # 遞回, url遞回深層爬取

24.linux和windows互傳檔案的軟體 lrzsz

yum install lrzsz -y
	命令:
		rz #接收檔案(從win中接收檔案)
		sz # =發送給檔案(發送linux檔案給win)
	example:
		sz csdn.png
		可以從win中拖檔案到shell命令列直接發送檔案到linux端

25.linux下如何安裝python3

? 1.yum安裝

? 2.rpm包安裝,需要手動解決依賴關系,很惡心

? 3.源代碼編譯安裝(公司都用這種方式), 可以自定義軟體版本, 以及功能擴展

編譯安裝python3的步驟:

?

1.下載python3的源代碼
	wget https://www.python.org/ftp/python/3.10.7/Python-3.10.7.tgz
2.解壓縮源代碼
	tar -xf Python-3.10.7.tgz
	# tar是解壓縮的命令
	# -x是解壓引數
	# -f指定一個解壓縮檔案的名字
3.必須解決編譯安裝所需的軟體依賴,比如OS的gcc等
	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
4.解決了軟體依賴關系, 就可以編譯安裝了
	1.釋放makefile,釋放編譯檔案 
		cd Python-3.10.7/
		./configure --prefix=/opt/python310/#告訴編譯器,python3安裝到哪里(prefix: 指定安裝路徑)
	2.執行make指令,開始編譯,編譯完成后進行安裝
		make && make install
	3.配置python310環境變數
		echo $PATH #顯示系統環境變數
		pwd #獲取當前python.exe位置 -> /opt/python310/bin
        PATH="/opt/python310/bin://usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin" #添加python環境變數
         # 但以上方式都是臨時生效(臨時賦值), 一旦重啟linux就會銷毀, 永久生效需要寫入到linux 全域變陣列態檔中/etc/profile
         vim /etc/profile
         #在最底行寫入以下配置即可(相當于簽訂協議)
                                                                                                         PATH="/opt/python310/bin://usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin"                                      
         # 然后讀取組態檔生效(給協議蓋章生效)
         source /etc/profile
Tips: [
		PATH:
			每個command其實都存在一個目錄里如/usr/local/bin...
			可以用 which ls來查看->
                alias ls='ls --color=auto'
                /usr/bin/ls
        在Linux下很多命令是用python2寫的,請不要擅自更改python為python3, 這樣會導致很多命令無法使用, 必須使用python3或python3.x來運行你想要的版本
]	
		

26.linux切換用戶

su <user_name>
su root
su zzy

在python中一個檔案夾下有__init__.py檔案, 那么這個目錄我們稱之為包

linux下進行django開發

?	1.創建django專案

?		django-admin startproject my_site

?	2.修改django配置

?		127.0.0.1 #本機回環地址, 只能自己訪問到自己, 每臺機器都有

?		0.0.0.0 #代表系結這臺機器所有的網卡,所有人均可訪問(因為一臺機器有不同的ip地址)

?		192.168.44.148 vlan0
					  vlan1
					  ...
					  
		'關閉linux防火墻'
		iptables -F #清空防火墻規則
		systemctl stop firewalld #禁用防火墻
		systemctl disable firewalld #禁用防火墻永久
		
		修改settings.py 引數allowed_host允許為 -> "*"
	3.運行django專案
		python3 manage.py runserver 0.0.0.0:8000 #如果專案啟動在這個地址上, 系結了這個機器的所有ip, 自己可以通過 127.0.0.1:8000
	4.撰寫一個下課試圖, 回傳一個大家51快樂, 玩的嗨皮

27.網路

1.管理網路的命令

如果發現自己沒有ip地址
	1.保證vmware的網路小電腦亮著,如同插上了網線
	2.管理網路的檔案夾路徑:
		/etc/sysconfig/network-scripts/
	3.查看管理網路的檔案內容
		ifcfg-ens33 這個就是網卡的組態檔了
	4.確保一個引數是yes
		ONBOOT="yes" #代表機器啟動時,就加載ip地址
	5.通過命令重啟網卡
		systemctl restart network
		系統服務管理命令 重啟 網路服務

2.啟停網卡的快捷命令

ifup
ifdown

3.linux的用戶限權篇

? qq群角色分配

? 超級用戶: 群主 root

? 擁有超級用戶權限的人: 管理員 sudo 加上你的命令 (臨時提權)

? 渣渣用戶: 普通成員

? 權限的目的:便于管理

? 創建用戶

? useradd

? 更改用戶密碼

? passwd <用戶名>

? root用戶就是皇帝, 他的皇宮就在/root

? 普通用戶,只有一個小破房子, 還是統一管理的地方/home

? 普通用戶資訊都存放到了/etc/passwd

4.查看linux用戶的身份id資訊

語法:
	id <用戶名> #查看用戶身份id
效果:
	[root@localhost etc] id zzy
	uid=1000(zzy) gid=1000(zzy) 組=1000(zzy),10(wheel)
決議:
	uid 用戶id號碼
	gid group id 用戶組 id
	groups 組id好碼
系統超級用戶uid默認是0
系統常用服務的用戶 系統more會創建mysql用戶,去執行mysql這個軟體,他的id是從1-999之間
root創建的普通用戶, 默認id是從1000開始的

用戶組:一組同樣身份資訊的用戶
用戶, 普通用戶

5.root可以隨便更改別人的密碼, 普通用戶不行

6.用戶切換

root可以隨意切換普通用戶
普通用戶切換必須輸入密碼
su - zzy #切換用戶(全切換,包括環境變數資訊......)

7.臨時提權的命令

1.修改sudoers組態檔, 把你想提權的用戶寫入進去
	vim /etc/sudoers
2.寫入如下資訊, 可以定位到那一行
	## Allow root to run any commands anywhere
	zzy    ALL=(ALL)    ALL #允許zzy在任何地方, 執行任何命令

8.洗掉用戶

userdel洗掉用戶
引數:
	-f 強制洗掉用戶
	-r 同時洗掉用戶及家目錄
	userdel -r pyyu
tips:
	如果直接 userdel zzy ,只會洗掉zzy用戶在/etc/passwd存放的用戶資訊, 而用戶的家目錄會保留

9.linux的檔案權限

'檔案擁有者分為三類
    屬主 users
    屬組 group
    其他人 other
'權限主要分三重身份:
	* user/owner 檔案使用者,檔案屬于哪個用戶
	* group 屬組,檔案屬于哪個組
	* others既不是user, 也不是group, 就是other, 其他人
-rw-r--r--. 1 root root 0 1月  11 16:55 haha.txt
限權 檔案鏈接數 屬主 屬組 檔案大小 修改日期時間 檔案名
'什么是限權:
	在Linux中每個檔案都有所屬的所有者,和所有組,并且規定了檔案的所有者,所有組以及其他人對檔案的, 可讀, 可寫, 可執行等權限.
	對于目錄的權限來說,可讀是讀取目錄檔案串列,可寫是表示在目錄內新增,修改,洗掉檔案,可執行表示可以進入目錄
'檔案讀寫執行命令:
    cat 讀
    vim echo 寫
    ./檔案 直接運行可執行檔案, 以絕對路徑和相對路徑
    sh first.sh #用linux自帶的shell腳本執行
'檔案夾的讀寫執行:
	ls 讀
    touch 寫入檔案到檔案夾
    cd 允許進入檔案夾, 代表可執行
'linux的檔案分類:
	- 普通文本
	d 檔案夾/目錄
	l 軟連接
'檔案/檔案夾的權限:
	r read可讀,可以用cat命令查看
	w write寫入,可以編輯或洗掉這個檔案
	x executable 可以執行
'實體解釋->
	-rw-r--r--. 1 root root  0 1月  11 16:55 haha.txt
	#-表示文本檔案, rw指這個檔案的屬主root用戶是可讀可寫但不可執行, 中間的r--表示只讀(屬組)root這個組的成員都可以讀,后面兩個--表示沒權限,后面r--指的是其他人對這個檔案的權限是只讀.

10.更改檔案權限

chmod 權限 檔案/檔案夾權限
-rw-r--rw-. 1 rrot root 79 May 5 09:58 nihao.txt
'決議:
	- 普通文本
	rw- 指的是root用戶 可讀可寫不可執行(因為這是個文本檔案無法執行)
	r-- 指的是root組里的成員, 只讀
	rw- 指的是其他人 可讀可寫 不可執行
'實體:
    `如何取消所有人對此檔案(nihao.txt)的權限:
        chmod u-r,u-w,u-x nihao.txt #改屬主的權限
        chmod g-r,g-w,g-x nihao.txt #改屬組的權限
        chmod o-r,o-w,o-x nihao.txt #改其他人的權限
    `讓檔案:nihao.txt 所有角色擁有全部權限
    	chmod 777 nihao.txt
    限權分為: 
    	r 4
    	w 2
    	x 1
    限權計算最高是4+2+1=7 最底是0
    `練習chmod, 實作如下效果:
    ---xr---wx. 1 root root 79 May 5 09:58 nihao.txt
    	chmod 143 nihao.txt
    -r--r---wx. 1 root root 79 May 5 09:58 nihao.txt
    	chmod 443 nihao.txt
    
    

tips:

權限分配	檔案所有者	檔案所屬組	其他用戶
權限項	讀|寫|執行	讀|寫|執行	讀|寫|執行
字符表示	r|w|x	r|w|x	r|w|x
數字表示	4|2|1	4|2|1	4|2|1

11.更改檔案的屬主/屬組

chown <用戶名> <要操作的檔案> #更改檔案屬主
chgrp <用戶組> <要操作的檔案> #更改檔案屬組

12.軟連接

語法:
ln -s 目標檔案 快捷方式(絕對路徑)

13.linux的命令提示符

PS1變數
echo $PS1 #顯示命令提示符
PS1="[\u@\h \w \t]\$" #修改命令提示符
pyyu:
	可以自行調整全域變數/etc/profile檔案用于永久生效 PS1='[\u@\h \W\t]\$'
\d　　日期
\H　　完整主機名
\h　　主機名第一個名字
\t　　時間24小時制HHMMSS
\T　　時間12小時制
\A　　時間24小時制HHMM
\u　　當前用戶賬號名
\v　　BASH的版本
\w　　完整作業目錄
\W　　利用basename取得作業目錄名
\#　　下達的第幾個命令
\$　　提示字符，root為#，普通用戶為$
PS1 > 變數名
$PS1 > 查看變數內容
PS1=新內容 重新賦值

變數賦值，查看
name='chaoge'
echo $name

PS1顯示ip地址
export PS1="[\u@\h `/sbin/ifconfig ens33 | sed -nr 's/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p'` \w]\$"

14.linux的打包,解壓的命令

tar命令:
	'引數:
		-A或-catenate 新增檔案已存在的備份檔案
		-B 設定區塊大小
		-c或--create 建立新的備份檔案
		-C <目錄> 這個選項用在解壓縮,若要在特定的目錄解壓縮, 可以使用這個選項
		-d：記錄檔案的差別；
		-x或--extract或--get：從備份檔案中還原檔案；
        -t或--list：列出備份檔案的內容；
        -z或--gzip或--ungzip：通過gzip指令處理備份檔案；
        -Z或--compress或--uncompress：通過compress指令處理備份檔案；
        -f<備份檔案>或--file=<備份檔案>：指定備份檔案；
        -v或--verbose：顯示指令執行程序；
        -r：添加檔案到已經壓縮的檔案；
        -u：添加改變了和現有的檔案到已經存在的壓縮檔案；
        -j：支持bzip2解壓檔案；
        -v：顯示操作程序；
        -l：檔案系統邊界設定；
        -k：保留原有檔案不覆寫；
        -m：保留檔案不被覆寫；
        -w：確認壓縮檔案的正確性；
        -p或--same-permissions：用原來的檔案權限還原檔案；
        -P或--absolute-names：檔案名使用絕對名稱，不移除檔案名稱前的“/”號；
        -N <日期格式> 或 --newer=<日期時間>：只將較指定日期更新的檔案保存到備份檔案里；
        --exclude=<范本樣式>：排除符合范本樣式的檔案，
    '重要:
    	-c 打包
    	-x 解包
    	-z 呼叫gzip目錄取壓縮檔案,節省磁盤空間
    	-v 顯示打包程序
    '實體:
    	壓縮當前的所有內容到alltmp.atr這個檔案中, 這里不節省磁盤空間
    		tar -cvf alltmp ./*
    	壓縮tmp下的zzy檔案夾為zzy.tar.gz
    		tar -zcvf zzy.tar.gz zzy
    	解壓的方式
    		tar -zxvf 壓縮檔案的名字.tar.gz
    	打包檔案,并且壓縮檔案大小的用法
    		tar -zcvf 壓縮檔案的名字.tar.gz
    	

15.django程式起來,如何檢測呢?

1.去瀏覽器檢測是否可以訪問, 127.0.0.1:8000
2.確認django的埠是否啟動
	netstat -tunlp | grep 8000
2.確認django的行程是否存在
	ps -ef | grep python

16.殺死行程的命令

kill 行程id
kill -9 行程id #強制殺死行程

17.支持正則的kill命令(慎用)

pkill 行程的名字
pkill -9 行程名字 #強制殺死

18.顯示磁盤空間大小

df 
df -h 以單位顯示

19.什么是DNS(域名決議系統),其實就是一個超大的網路電話簿

dns就是域名決議到ip的一個程序,
大型公司,用的dns服務名叫做bind軟體
提供dns服務的公司有:
	119.29.29.29 騰訊
	223.5.5.5 阿里
	223.6.6.6 阿里
	8.8.8.8 谷歌的
	114.114.114.114 114公司的
linux的dns組態檔如下:
	vim /etc/resolv.conf 里面定義了dns服務器地址
	
	linux決議dns域名
	nslookup 域名	

20.dns決議流程,當你在瀏覽器輸入一個url,有了那些決議

pythonav.cn:80/index.html
決議流程:
	1.瀏覽器首先在本地機器操作dns快取中查找是否有域名-ip的對應記錄
	2.去/etc/hosts檔案中尋找是否寫死了域名決議記錄
	3.如果hosts沒寫,就取/etc/resolv.conf組態檔中尋找dns服務器地址
	4.如果找到了對應的決議記錄,就混存到本dns快取中
	/etc/hosts 本地強制dns的檔案

21.linux的定時任務

語法:
    分  時  日	  月	 周
    *	*	*	*	* 命令的絕對路徑
實體:
	#每分鐘執行一次命令
	* * * * * 命令的絕對路徑
	#每小時的3,15分組執行命令
	3,15 * * * * 命令的絕對路徑
	#晚上的8-11點的第3和第15分鐘執行
	3,15 20-23 * * * 命令的絕對路徑
	#每晚的21:30執行命令
	30 21 * * * 命令的絕對路徑
	#每周六,周日的1:30執行命令.(7或0都可以代表周日)
	30 1 * * 6,7 命令的絕對路徑
	#某周一到周五的林晨一點,清空/tmp目錄的所有檔案
	00 1 * * 1-5 /usr/bin/rm -rf /tmp/*
	#每晚的21:30重啟nginx
	30 21 * * * /usr/bin/systemctl restart nginx
	#每月的1,10,22日的4:45重啟nginx
	45 16 1,10,22 * * /usr/bin/systemctl restart nginx
	#每個星期一的上午8點到11點的第3和第15分鐘執行命令
	3,15 8-11 * * 1

22.linux的軟體包管理

軟體包的格式(了解即可):
	win: exe
	mac: dmg
	linux: rpm
安裝軟體的方式:
	1.yum安裝(自動搜索你想要的軟體包,以及他的依賴關系,自動解決下載)
	2.源代碼編譯安裝
	3.手動安裝rpm包(手動解決依賴關系)
	rpm命令的使用方式:
		安裝 rpm -ivh xxx.rpm #i安裝,v顯示詳細程序,h進度條顯示
		升級 rpm -Uvh xxx.rpm
		卸載 rpm -e xxx.rpm
		

linux配置阿里云的yum源, 配置步驟如下

1.找到阿里的鏡像站:
	https://opsx.alibaba.com/mirror
2.通過命令在線下載yum源(-)
	wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
	下載epel,選擇epel(RHEL 7)
	wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
	# 在線下載repo倉庫檔案,并且重命名,放到/etc/yum.repos.d/這個目錄
下-O就是改名,且下載到指定位置
3.備份默認的yum倉庫
	Linux的yum倉庫地址說 -> /etc/yum.repos.d
	在這個目錄的第一層檔案夾下,名字以*.repo結尾的都會被識別為yum倉庫
	例如 -> /etc/yum.repos.d/xxx.repo
	配置:
		cd /etc/yum.repos.d
		mkdir backrepo
		mv * ./backrepo
4.測驗安裝mariadb資料庫(其實就是MySQL)
	yum install mariadb-server  mariadb -y
5.啟動資料庫
	systemctl start mariadb
6.可以測驗訪問mysql資料庫了
	mysql -uroot -p
7.更新yum快取
	yum clean all && yum makecache

系統服務管理命令(只有通過yum安裝的軟體,才可以用系統服務管理命令)

1.如果是centos6就是
	service nginx start
3.如果是centos7就是
systemctl  start/stop/restart nginx

230130

作業

作業
	1.配置好阿里云yum源
	生成yum快取
	下載nginx,并啟動nginx服務,使用瀏覽器訪問nginx頁面
        2.備份原來的yum源,原本是centos.repo國外的資料快取
        3.下載阿里云的yum源檔案,兩條wget命令下載repo倉庫檔案
        4.清空原本的yum快取, yum clean all
        5. yum makecache生成yum快取
        6. yum install nginx -y

	yum源的作業目錄是?
		/etc/yum.repos.d/ 在這個目錄下所有名字是*.repo的檔案,就會背識別為倉庫檔案
	2.下載lrzsz工具,方便win和linux互傳檔案
		yum install lrzsz -y
	3.如何手動啟動網卡?(如果發現自己沒有ip地址)
		語法:
			ifup 網卡名
		實體:
            ifup ens33
            ifup eth0
         systemctl start network
     4.linux的超級用戶是什么?如何查看用戶身份資訊?
     	root
     	id root
     5.簡述linux的用戶管理
     	useradd zzy 添加用戶
     	userdel zzy 洗掉用戶
     	passwd zzy 更改用戶密碼
     	1.用戶角色有 usergroup other
     	2.超級root 普通用戶是root創建的
     	3.root超級用戶uid是0,普通用戶uid從1000開始
     	普通用戶執行命令權限不足時可以配置sudo命令即可
     6.如何使用普通用戶登錄
     	ssh
     7.在linux下如何切換用戶
     	su -用戶名
     8.如何使用root身份執行普通用戶的命令?請詳細說明配置步驟
     	1.修改/etc/sudoers檔案
     	2.找到:
        root ALL=(ALL)    ALL
        zzy ALL=(ALL)    ALL
        3.保存退出即可
        4.sudo ls /root 
        5.可以使用visudo命令提供語法檢測,更正規
        
     9.簡述linux的檔案權限有哪些?
     	r w x
     	4 2 1
     	777
     10.linux檔案權限的755,700是什么意思?
     	-rwxr-xr-x
     	-rwx------
     11.如何修改test.py檔案權限為700
     	chmod 700 test.py
     12.如何修改test.py屬組是oldboy?
     	chgrp oldboy test.py
     13.已知test.py檔案權限是rwxr--r--,如何修改權限為rw-rw-rw
     	chmod 666 test.py
     14.linux如何建立軟連接?
     	ln -s opt/python3/bin /usr/local/python3
     	ln -s 目標絕對路徑 快捷方式絕對路徑
     15.linux的PS1變數是什么?如何修改
     	PS1是控制命令提示符的
     	PS1='{\u@\h \w\t}\$' (變數賦值臨時生效)
     	系統全域環境組態檔, 針對每一個用戶 /etc/profile
     16.centos7用什么命令管理服務?
     	systemctl
     	centos6: service
	17.linux決議dns的命令是什么?
		nslookup www.oldboydu.com
		cat /etc/resolv.conf
		
	18.將/tmp/下所有內容壓縮成all_log.tar.gz并且放到/home下
		tar -zcvf /home/All.log.taar.gz /tmp/*
		-z呼叫gzip壓縮指令
		-c進行打包
		-v顯示程序
		-f指定一個檔案,這個引數必須寫在最后  
	19.解壓縮Python原始碼包Python-3.7.0b3.tgz
		tar -zxvf Python-3.7.0b3.tgz
	20.查看mysql埠狀態
		netstat -tunlp | grep 3306 #查到記錄了,說明機器開放了3306埠,mysql啟動了
	21.如何查看nginx的行程
		ps -ef | grep "nginx"
	22.如何殺死nginx行程
		kill nginx的pid
		pkill nginx   
    23.如何修改linux中文
    	1.保證linux的編碼是utf-8
    	2.保證你登陸的xshell也是utf-8
    	3.中文統一對應
    24.如何統計/var/log大小
    	du -sh /var/log
    25.tree是什么作用?
    	以樹狀圖顯示檔案夾內容\
    26.如何給linux添加一個dns服務器記錄
    	dns服務器記錄在 /etc/resolv.conf 檔案里
    	可以用echo追加,也可以vim編輯添加
    	但注意只能添加最多兩條記錄
    27.每月,5,15,25天的晚上5點50重啟nginx
    	*	*	*	*	*
    	50	17	5,15,25	*	* /usr/bin/systemctl restart nginx
    28.每周3到周5的深夜11點備份/var/log/放到/tmp目錄下
    	00	23	*	*	3-5 /usr/bin/cp -r /var/log/ /tmp
    29.每天早上6.30清空/tmp內容
    	*	*	*	*	*
    	30	6	*	*	* /usr/bin/rm -rf /tmp/*
    30.每個周三下午6點到8點的第5,15分鐘執行命令 command
    	5,15 18-20 * * 3 command
    31.編譯安裝軟體有哪些步驟?
    	注意要解決軟體依賴關系
    	1.下載軟體原始碼
    	2.解壓縮原始碼包
    	3.進入原始碼包目錄
    	4.編譯三部曲
    		釋放makefile, 執行configure腳本, 并且指定安裝路徑
    		開始編譯, 執行make指令
    		編譯安裝 make install
    32.如何修改python3環境變數, 以及軟連接
    	#軟連接方式:
    		ln -s /opt/python310/bin/python3.10.7 /usr/bin/python3
    	#配置PATH變數
    		
    33.請在linux上啟動ob_crm, windows上進行訪問,進行登錄
    	1.如何代碼在碼云上可以git clone
    	2.如果在win上可以通過lrzsz發送到linux
    	3.如果是壓縮檔案,進行解壓縮,生成代碼檔案
    	4.修改組態檔,allow_hosts=["*"]
    	5.如果用的是mysql, 還得提前啟動mysql,并且注意settings.py資料庫連接配置
    	6.遷移資料庫
    	7.解決所有crm依賴的模塊, 如django, pymysql
    	8.啟動,注意ip地址和埠的問題
    	9.pip裝的包,發給到解釋器的site-packages目錄下
    	10.yum安裝的軟體,是自動安裝的路徑, 可以通過rpm -ql查詢安裝路徑
    	11.如果向指定路徑安裝用原始碼包編譯安裝
    34.一月一日的4點重啟nginx
    	00	4	1	1	* /usr/bin/systemctl restart nginx
    35.每月4號與每周一到周三的11點重啟nginx
    	00	11	4	*	1-3 /usr/bin/systemctl restart nginx
    	
    36.每小時重啟一次nginx?
    	0	*	*	*	* /usr/bin/systemctl restart nginx
    37.每天10:00,16:00重啟nginx
    	00	10,16 * * * /usr/bin/systemctl restart nginx
    38.如何查看系統發行版資訊?
    	cat /etc/os-release
    39.系統全域環境變數的組態檔?
    	/etc/profile
    40.系統用戶的環境變陣列態檔是?
    	修改~/.bash_profile(首選),將影響當前用戶.
    	在~/.bash_profile檔案中添加
    41.如何查看記憶體大小資訊?
    	cat /proc/meminfo | grep MemTotal
    	free -m
    42.如何查看cpu核數?
    	cat /etc/proc/cpuinfo
    	top <鍵入1>
    	lscpu
    43.如何停止centos7防火墻服務,并且禁止防火墻開機自啟?
    	#防火墻作用: 保護服務器的流量網路安全, 允許/禁止 ip地址段和埠的出入流量 
    	systemctl stop firwalld.service #關閉防火墻服務
    	systemctl disable firwalld.service #緊張防火墻開機自啟
    	iptables -f #清空防火墻規則

vim

移動游標:
	w(e) 移動游標到下一個單詞
	b 移動到游標上一個單詞
	
	數字0 移動到本行開頭
	$ 移動游標到本行結尾
	
	H 移動游標到螢屏首行
	M 移動到游標到螢屏中間一行
	L 移動游標到螢屏的尾行
	gg 移動游標到檔案的首行
	G 移動游標到檔案尾行
	
	ctrl+f 下一頁
	ctrl+b 上一頁
	`. 移動游標到上一次的修改行
	
查找:
	/change 在整篇檔案中搜索change字串,向下查找
	?change 在整篇檔案中搜索change字串,向上查找
	*查找整個檔案,匹配游標1所在的單詞,按下n查找下一處,N上一處
	# 查找整個檔案,匹配游標所在的所有單詞,按下n查找下一處,N上一處
	gd 找到游標所在單詞匹配的單詞,并停留在非注釋的第一個匹配上
	% 找到括號的另一半!!
略...

------------------------------------------------------------
設定vim的tab鍵為4個空格
vim /etc/vimrc
底部寫入以下內容:
set ts=4
-----------------------------------------------------------

vim替換

# Vim替換字串命令的語法
# Vim替換字串命令的基本語法是 :[range]s/目標字串/替換字串/[option]，其中range和option欄位都可以預設不填，

# 下面介紹VIM替換字串各個變數的含義：
range:表示搜索范圍，默認表示當前行;
range欄位值1,10表示從第1到第10行;
%表示整個檔案(相當于1,$);
而.,$代表從當前行到本檔案的末尾
s：substitute的簡寫，表示執行替換字串操作;
option:表示操作型別，默認只對第一個匹配的字符進行替換；
option欄位值g(global)表示全域替換;
c(comfirm)表示操作時需要確認;
i(ignorecase)表示不區分大小寫;
vim替換字串的這些選項可以組合使用

命令列補充:

在命令列中tab代表補全 雙tab代表顯示提示

方向上 補全上一條指令

方向下 回到下一條指令

ctrl + c 強制結束行程

ctrl + insert 復制

shift+ insert 粘貼

常用退出應用程式命令列:

exit

quit

q

deactive

python虛擬環境

1.python虛擬環境, 用于解決python的環境依賴沖突的問題,僅僅是多個解釋器的分身,多個解釋器的復制,和作業系統無關

2.python虛擬環境的工具有很多:virtualenv, pipenv, pyenv
3.virtualenv可以在系統中建立多個不同并且相互不干擾的虛擬環境

注意: 確保python3成功的安裝,并且PATh配置在第一天路勁
virtualenv的學習安裝使用
	1.下載安裝
	pip3 install virtualenv
	2.安裝完畢,就可以使用命令創建虛擬環境使用了
	#這個命令在哪敲,就會在那生成
	virtualenv --no-site-packages --python=python3 venv
        #引數解釋
        --no-site-packages #沒有任何的第三方包,用于構建干凈的環境
        --python=python3 #指定python虛擬環境的本體,是py的哪個版本
        venv 就是一個虛擬環境的檔案夾,是虛擬python解釋器
    3.創建完畢venv虛擬環境,就可以激活使用了
    進入venv/bin目錄下
    source activate #source是讀取指令,讀取這個activate腳本中的內容,激活虛擬環境
    4.驗證虛擬環境是否正確
    which pip3
    which python3 都來自與venv路徑,就是對了
    5,使用虛擬環境,分別構建django1和django2的平臺
    注意, 開啟2個linux視窗
    步驟1:分別下載兩個venv1 venv2, 用于運行不同的django
    virthualenv --python=python3 venv1
    virthualenv --python=python3 venv2
    步驟2:這兩個虛擬環境,都得單獨激活去使用
    source venv1/bin/activate #激活虛擬環境
    source venv2/bin/activate #激活虛擬環境
    deactivate #退出虛擬環境
        

保證本地開發環境和線上一致性的步驟

1.匯出本地python的環境的所有模塊
pip3 freeze > requirements.txt
2.將這個依賴檔案發送給服務器linux
requiements.txt
3.服務器linux上,構建虛擬環境,安裝這個檔案,即可
pip3 install -r requirements.txt

virtualenvwrapper的學習使用

1.安裝
pip3 install virtualenvwrapper
2.配置環境變數,每次開機都加載這個工具,注意的是配置的是個人環境配置變陣列態檔
export WORKON_HOME=~/Envs # 設定virtualenv的統一管理目錄
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages' #添加virtualenv的引數,生成干凈隔絕的環境
export VIRTUALENVWRAPPER_PYTHON=/usr/local/python3/bin/python3 #指定python解釋器,虛擬環境以誰去分身
export /usr/local/python3/bin/virtualenvwrapper.sh #執行virtualenvwrapper安裝腳本

3.此時退出linux終端回話,重新登錄,rangvirtualenvwrapper工具生效
4.學習virtualenvwrapper命令,管理虛擬環境
	mkvirtualenv 虛擬環境的名字 #創建虛擬環境, 存放目錄是統一管理的
	workon 虛擬環境的名字 #可以在任意目錄直接激活虛擬環境(切換)
例如從venv1, 切換到venv2
	deactivate #退出虛擬環境
	rmvirtualenv 虛擬環境的名字 #洗掉虛擬環境
	lsvirtualenv #列出所有虛擬環境
	cdvirtualenv #進入虛擬環境的目錄
	cdsitepackages #進入虛擬環境的第三方包
	mkvirtualenv -p /opt/python3.6.4/binpython3.6 #指定python版本安裝

nginx

nginx web server

1.靜態網站,靜態虛擬主機的作用
	就是不變化的網頁,靜態的html,css,js的頁面, 以及各種圖片視頻的資源
	有一些草根站長,放一些小說, 圖片等等...
	
2.動態網站
指的是,可用于資料庫打交道,資料互動的網頁,網頁內容根據資料庫的資料變化
登錄功能,有注冊功能的...
并且有編程語言支持的
3.nginx的并發非常強悍
	輕松支持10w+并發連接數
tnginx
4.常見web服務器有哪些?
	win下 -> IIS服務器
	linux下 -> nginx apache lighthttp
	apache采用多行程方式非常吃系統資源
	nginx采用異步非阻塞, 輕量級, 穩定豐富的功能, 系統資源消耗低且高并發
5.web服務器
	nginx 這樣的軟體
	web服務器它自己不支持變成, 僅僅是頁面回傳, nginx + lua
  web框架的概念
  	django flask tornado web邏輯框架
  	支持程式員自己寫代碼,進行邏輯處理
6.nginx是web服務器, 反向代理服務器, 郵件代理服務器, 反向代理,負載均衡, 支持高并發的一款web服務器
7.nginx安裝方式
	1.yum
	2.rpm手動
	3.源代碼編譯安裝,選擇這個,支持自定義的第三方功能擴展,比如自定義安裝路勁,支持https,支持gzip資源壓縮
8.選擇原始碼編譯安裝
	1.下載淘寶nginx(tengine)的原始碼包
	wget http://tengine.taobao.org/download/tengine-2.3.0.tar.gz
	2.解壓縮原始碼包
	tar -zxvf tengine-2.2.0.tar.gz
	3.進入原始碼目錄開始編譯安裝
		./configure
		make&&make install
	4.配置淘寶nginx的開發環境
	PATH="/usr/local/python3/bin://usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/tngx230/sbin"
	讀取/etc/profile
		source profile
	5.啟動nginx,不得再啟動第二次
		nginx #啟動
		
	nginx -s reload #平滑重啟nginx,重新讀取nginx組態檔
	nginx -s stop #停止nginx行程
	nginx -t #對組態檔資訊進行語法檢測
	
	6.學習nginx的目錄組態檔資訊
		client_body_temp  html	sbin	conf	logs   scgi_temp	fastcgi_temp	proxy_temp  uwsgi_temp
		#解釋目錄
		conf 存放nginx組態檔的
		html 存放前端檔案目錄, 首頁檔案就在這里
		logs 存放nginx運行日志,錯誤日志的
		sbin 存放nginx執行腳本的
	7.部署一個web站點
		修改index.html檔案, 即可查看新頁面內容
		
	8.nginx組態檔學習
		見下一個nginx代碼塊
	9.nginx的錯誤頁面優化
		打開nginx.conf里面的如下引數
		error_page 404 	/404.html;
	10.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;
    11.nginx限制訪問功能
    	就是nginx.conf中 找到location引數,寫入如下資訊
    	location / {
    	   deny 192.168.44.189; #禁用某個用戶的ip地址
    	   deny 192.168.16.0/24; /24子網掩碼地址 255.255.255.0
            root   html; #定義網頁根目錄的,是nginx目錄下的html 
            index  index.html index.htm; #指定首頁檔案的名字
        }
    12.nginx的狀態資訊功能, 檢測當前有多少個鏈接數
    	再nginx.conf下打開一個引數即可
    	#當你的請求來自于 192.168.16.37/
    	location /status {
    				#開啟nginx狀態功能
    				stub_status on;
    	}
    
    使用linux的壓測命令,給nginx發送大量的請求
    ab命令
    安裝方式
    yum install httpd-tools
    -n requetst #執行的請求數,即一共發起多少請求.
    -c concurrency #請求并發數.
    -k #啟用HTTP KeepAlive功能, 即在一個http會話中執行多個請求
    url格式必須如下
    ab -kc 1000 -n 100000 http:/192.168.44.160/
    
    13.多虛擬主機,在一臺服務器上運行多個網路頁面 
    	基于多域名的虛擬主機實作, 其實就是讀個server標簽
    	環境準備, 1個linux服務器, 192.168.44.160
    	2個域名, 寫入hosts檔案,強制
    	www.s19dnf.com
    	www.hanju.com
    修改nginx.conf, 也就是寫兩個平級的server, 并且更改server_name
    
    14.nginx的反向代理功能
    	1.見過生活中的代理
    	客戶端(請求資源)  -> 代理(轉發資源) ->  服務端(提供資源)
    	客戶端和nginx
    	`示例:
    		nginx與django聯合, nginx負責靜態頁面, 當請求為動態需要涉及到資料庫操作, nginx將轉發請求給django, 由django負責.
    	
    	正向代理:
    		多人連接到proxy,由proxy去訪問再提供給用戶
    	反向代理:
    		
    配置nginx實作反向代理的步驟:
    環境準備兩臺機器
    192.168.43.156 充當資源服務器, 提供一個頁面
    
    
    192.168.43.6  充當代理服務器的角色(轉發請求, 反向代理的功能也是nginx提供的)
    	--修改如下配置(nginx.conf)
    	#當你的請求來自于192.168.43.156/這樣的url時就進入如下路徑
匹配
        location / {
            #當請求進來這個路徑匹配,這個nginx代理角色,直接轉發給>資源服務器
            proxy_pass 192.168.43.156;
        }
    
    	3.測驗訪問反向代理的頁面
    	

nginx反向代理原理圖

client端訪問 --> ng2(代理服務器) -->  找ng1拿取資源 --> 回饋給用戶

nginx組態檔內容如下:

#全域變數寫在最外層
#user  nobody;
worker_processes  4;

events {
    worker_connections  1024;
}

#定義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;
    #access_log  "pipe:rollback logs/access_log interval=1d baknum=7 maxsize=2G"  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    圖片壓縮資源壓縮
    #gzip  on;
        
    nginx主頁面功能都是server引數提供的
    server被稱作是虛擬主機
    server {
        #nginx監聽的埠
        listen       80;
        #填寫服務器的域名, 或者ip, 或者localhost
        server_name  localhost;
        
		#路徑匹配, 當你的請求來自于192.168.16.37/就進入以下的location路勁匹配
        location / {
            root   html; #定義網頁根目錄的,是nginx目錄下的html 
            index  index.html index.htm; #指定首頁檔案的名字
        }
        
        #錯誤頁面
        #當請求回傳404錯誤碼的時候, 就給用戶看到一個頁面
        #這個404.html放在網頁根目錄下
        error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

nginx知識點

支持高并發,能支持幾萬并發連接
資源消耗少,在3w并發連接下開啟10個nginx執行緒消耗記憶體不到200m
可以做http反向代理和負載均衡
支持異步網路i/o事件模型epoll

tengine

由淘寶網發起的web服務器專案,在nginx基礎上,針對大量訪問網站的請求,添加了很多高級功能和特性.tengine的性能和穩定性已經在大型網站如淘寶天貓商城得到很好的驗證.他的最終目的是打造一個高效,穩定,安全,易用的web平臺

nginx引數篇

worker_processes 4; # 設定作業行程數

內容小結

1.編譯安裝tengine服務

編譯三部曲
1.解決軟體編譯安裝所需的依賴
2.下載軟體源代碼包, 并且解壓縮出原始碼包內容
3.進入原始碼包目錄, 執行./configure --prefix=安裝絕對路徑, 釋放編譯檔案, makefile
4.呼叫linux的編譯器 make && make install 開始安裝軟體

2.nginx的核心作業目錄

conf 存放nginx.conf的目錄, 功能配置都在這
logs 存放err.log access.log
html (網頁根目錄) 存放index.html 404.html

3.nginx提供web服務器頁面的功能引數就是server{ }虛擬主機標簽

#server虛擬主機,nginx會自上而下的加載, 因為可能有多個虛擬主機
#虛擬主機定義了網站的埠, 域名, 網頁內容存放路徑
server {
    listen	80;
    server_name	www.s19dnf.com;
    location / {
        root	/opt/dnf/;
        index	index.html index.html;
    }
}
#nginx支持多虛擬主機,也就是通過多個server標簽實作的
server {
    listen	80;
    server_name	www.s19dnf.com;
    location / {
        root	/opt/dnf/;
        index	index.html index.html;
    }
}
#nginx會根據用戶訪問的url域名進行server_name域名匹配,然后選擇回傳不同的 虛擬主機內容

4.還有剩余的功能配置

404頁面
在虛擬主機server{}標簽中定義error_log引數
error_page	404				/404.html;

訪問日志功能, 放在http{}標簽中, 代表全域作用域, 對所有虛擬主機生效,寫在單獨的虛擬主機中, 就是區域變數

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;

5.反向代理功能引數

在虛擬主機中,找到location{}標簽,然后寫入
	proxy_pass 你想代理的服務器ip地址;

Nginx實作負載均衡, 動靜分離的效果

1.環境準備

192.168.43.157 資源服務器	提供dnf頁面
192.168.43.6 資源服務器	(講道理,應該是192.168.xx.xx一樣的代碼配置,一樣的頁面)
192.168.43.186 充當代理服務器,以及負載均衡的作用

2.分別配置三臺機器

192.168.43.157 資源服務器, 提供dnf頁面
192.168.43.6	資源服務器,提供小貓咪頁面
192.168.43.187	負載均衡的配置
	

3.nginx.conf修改為如下配置

1.添加負載均衡池, 寫入web服務器地址:
	upstream mydjango {
		#負載均衡的方式默認是輪詢, 1s一次
		server 192.168.43.157;
		server 192.168.43.6;
	}
	-----------------------------------
	upstream mydjango {
		#帶weight加權
		server 192.168.43.157 weight=2;
		server 192.168.43.6 weight=7;
	}
	-----------------------------------
	upstream mydjango {
		#按ip_hash分配
    	ip_hash;
		server 192.168.43.157;
		server 192.168.43.6;
	}

4.負載均衡的配置方式

location / {
    proxy_pass http://mydjango;
}

5.動靜分離的配置

1.配置動態請求的服務器
192.168.43.6 充當靜態服務器,回傳小貓咪的頁面,以及一些圖片資源

? 需要安裝nginx即可

#nginx.conf	配置如下
#當請求來自于192.168.43.6/時,就進入如下路徑匹配,回傳日劇頁面
        location / {
        root   html;
        index  index.html index.htm;
    }
#當請求時192.168.43..140/xx.jpg這樣的媒體資源,就進入如下location回傳/opt/nginx1223/html/images
    	location ~* .*\.(png|jpg|gif|jpeg)$ {
        root /opt/nginx1223/html/images;
    }

2.配置靜態請求的服務器
192.168.43.157 運行django頁面

1.先后臺運行django頁面
python3 manage.py runserver 0.0.0.0:8000 &
2.修改nginx配置, 可以轉發, 動靜的請求
    upstream mydjango {
        server 192.168.43.157:8000;
}
    upstream mystatic {
        server 192.168.43.6;
}
    server {
        listen       80;
        server_name  192.168.43.157;
        #當外部請求,是192.168.43.157時就進入如下location,回傳django頁面反向代理
        #charset koi8-r;

        #access_log  logs/host.access.log  main;
        #access_log  "pipe:rollback logs/host.access_log interval=1d baknum=7 maxsize=2G"  main;

        location / {
            proxy_pass http://mydjango;
        }
        #當外部請求時, 192.168.43.157:80/xx/jpg
        #就轉發給那臺靜態資源服務器去處理
        location ~ .*\.(png|jpg|gif|jpeg)$ {
                proxy_pass http://mystatic;
        }

3.在負載均衡器上,配置請求轉發
192.168.43.187 配置負載均衡動靜分離的配置

1.定義一個upstream地址池,進行請求分發
	upsrteam地址池,進行請求分發
    upstream myserver {
        server 192.168.43.157;
        server 192.168.43.6;
	}
2.通過location進行請求分發的作業
        location / {
            proxy_pass http://myserver;
        }

負載均衡的規則

### 調度演算法	概述
* 輪詢	|按時間順序逐一分配到不同的后端服務器(默認)
* weight	|加權輪詢, weight值越大,分配到的訪問幾率越高
* ip_hash	|每個請求按訪問的hash結果分配,這樣來自同一ip的固定訪問一個后端服務器
* least_conn	|最少鏈接數,那個機器鏈接數少就分發
-----------------------------------------------------------
注意輪詢,是假設1s內有兩個人請求, 那么則均衡配分.
前兩種方式最常用

ob_crm專案部署

django自帶了socket服務端嗎?wsgiref這個是python自帶的socket模塊,django默認用的是wsgiref的單機socket模塊

Python manage.py runserver 這是除錯命令,測驗django是否有問題的

最終上線是uwsgi + django的方式

為什么要用nginx結合uwsgi

? 1.nginx支持靜態檔案處理性能更好

? 2.nginx的埃軍和特性,讓網站并發更高

? 3.并且反向代理特性,用戶訪問80,即可訪問到8000的應用

? 4.uwsgi支持多行程的方式,啟動django,性能更高

? 5.nginx轉發請求給uwsgi,應該用uwsgi_pass,實作了uwsgi協議的請求轉發

如果出現錯誤: pytho app application not found

就是你的uwsgi沒找到uwsgi.py這個檔案物件 application = get_wsgi_application()

wsgiref: 
	python自帶的web服務器
	
gunicorn:
	用戶linux的python wsgi Http服務器,常用于各種django,flask結合部署服務器
	
mode_wsgi:
	實作了apache與wsgi應用程式的結合
	
uWsig:
	c語言開發,快速,自我修復,開發人員友好的WSGI服務器,用于python web應用程式的專業部署和開發

配置步驟

## 1.nginx+uwsgi+虛擬環境+mysq+supervisor

環境準備, 一臺linux(192.168.43.157)

### 第一步,先準備后端代碼 ob_crm
### 第二部:安裝py2解釋器,以及虛擬環境工具virtualenvwrapper
### 第三部,學習uwsgi命令, 通過uwsgi啟動ob_crm

## 1.激活虛擬環境,在虛擬環境下安裝所需的模塊
    安裝如下內容即可
    Django==1.11.20
    django-multiselectfield==0.1.12
    PyMySQL==1.0.2
    pytz==2022.7.1

## 2.安裝這個檔案
[linux] pip3 install -i https://pypi.douban.com/simple -r requirements.txt

## 3.安裝uwsgi命令
pip3.6 install uwsgi

## 4.學習uwsgi啟動django的命令
uwsgi --http :8000 --module mysite.wsgi --py--autoreload=1

--http 指定http協議
:8000 指定啟動埠
### --module 指定django的wsgi.py的檔案地址
	指定你的django專案第二層目錄名,下面的wsgi.py
	
--py-autoreload=1 開啟uwsgi的熱加載功能	1代表ture開啟的意思

所以咱們用的命令應該是如下:
	1.必須進入專案目錄
	/opt/teaching_plan/ob_crm
	
	2.使用命令啟動ob_crm(uwsgi不決議django的靜態檔案)
	uwsgi --http :8000 --module ob_crm.wsgi
	
	用ob_crm這個目錄去查找wsgi這個腳本檔案
	3.讓你的專案支持熱加載

由于uwsgi的啟動引數過多,我們會選則組態檔的方式,啟動專案

uwsgi.ini 這個檔案的名字,可以手動創建的

1.創建uwsgi.ini寫入如下引數

# mysite_uwsgi.ini file
[uwsgi]

# Django-related settings
# the base directory (full path)
# 填寫你專案的絕對路徑,第一層
chdir    = /opt/teaching_plan/ob_crm/
# Django's wsgi file
# 找到django的那個我wsgi.py檔案
# 根據上面一條引數,的相對路徑來寫
module   = ob_crm.wsgi
# the virtualenv (full path)
# 虛擬環境的絕對路徑
home     = /root/Envs/ob_crm
# process-related settings
# master 主行程
master   = true
# maximum numver of worker processes
# 根據你的cpu核數來定義
processes    = 4
# the socket (use the full path to be safe
# 指定你的django啟動在什么地址上并且是什么協議
# 如果你用了nginx反向代理, 請用socket引數
socket    =0.0.0.0:8000
# 如果未使用nginx反向代理, 想要直接使用django, 用這個引數:
# http = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum    =true
#開啟熱加載
py_autoreload = 1

2.通過組態檔啟動專案

uwsgi --ini uwsgi.ini

3.收集django的所有靜態檔案統一管理,丟給nginx決議

1.設定django專案的settings.py檔案

STATIC_ROOT = '/opt/s19static'  # 收集到任意一個目錄里
STATIC_URL='/static/'
STATICFILES_DIRS=[
    os.path.join(BASE_DIR, 'static'),
]

上述的引數STATIC_ROOT用在哪?

2.執行命令收集檔案

#### 通過$ python3 manage.py collectstatic 收集所有你使用的靜態檔案保存到STATIC_ROOT!

STATIC_ROOT 檔案夾 是用來將所有STATICFILES_DIR中所有的檔案夾中的檔案, 以及app中static的檔案都復制過來
# 把這些檔案放到一起是為了用nginx等部署的時候更方便

nginx配置來了!!!

1.nginx的反向代理

2.nginx決議靜態檔案的功能

        location / {
            uwsgi_pass 127.0.0.1:8000;
            include uwsgi_params;
        }
        location /static {
    		#給靜態檔案目錄設定別名,可以讓其源目錄訪問到真實的靜態目錄
            alias /opt/s19static;
        }

行程管理工具supervisor的使用

supervisor其實就是在幫咱們去執行命令

1.安裝supervisor,通過pip直接按照

pip3 install supervisor

2.生成supervisor的組態檔

echo_supervisord_conf > /etc/supervisor.conf

3.修改配置, 寫入你管理ob_crm的命令引數

vim /etc/supervisor.conf  #直接進入最低行, 寫任務

[program:s19_ob_crm]
command=/root/Evns/ob_crm/bin/uwsgi --ini /opt/teaching_plan/ob_crm/uwsgi.i
ni
stopasgroup=true    ;默認為flase,行程被殺死時, 是否這個行程組發送stop信號,
 包括子行程
killasgroup=true    ;默認為false, 向行程發送kill信號,包括子行程

4.通過命令啟動supervisor 同時啟用ob_crm

supervisorctl #管理命令
supervisord #服務端命令

啟動服務端的命令

supervisor -c /etc/supervisor.conf

通過客戶端命令管理ob_crm

[root@localhost conf]# supervisorctl -c /etc/supervisor.conf 
s19_ob_crm                       FATAL     can't find command '/root/Evns/ob_crm/bin/uwsgi'

任務名 狀態

[program:s19_ob_crm]
command=/opt/python3.6.4/bin/uwsgi --ini /opt/teaching_plan/ob_crm/uwsgi.ini
stopasgroup=true
killasgroup=true

訪問成功如下:

[root@localhost ob_crm]# supervisorctl -c /etc/supervisor.conf
s19_ob_crm                       RUNNING   pid 57569, uptime 0:01:37
supervisor> 


#此結果我足足等了一天了多,不知是什么bug,如果我寫虛擬環境的目錄,他總是找不到命令,于是我只能寫上物理環境中的命令uwsgi來啟動.哎哎哎

supervisor命令列操作

1.停止任務

supervisor> stop s19_ob_crm 
s19_ob_crm: stopped

2.查看任務狀態

supervisor> status
s19_ob_crm                       STOPPED   Feb 16 10:31 PM

3.啟動/停止所有的任務

supervisor> start all #開啟所有任務
s19_ob_crm: started
---------------------------------------------------------
supervisor> stop all #關閉所有任務
s19_ob_crm: stopped

部署內容回顧

整篇埠設計:

vue(靜態檔案夾dist) 也就是nginx回傳vue頁面,埠為80,也是nginx.conf提供的 server{}虛擬主機提供的
|
反向代理埠 8500 ,是通過nginx實作的,nginx.conf中撰寫一些引數,介面速率限制,爬蟲驗證,封停ip地址
|
django后臺地址 9000

1.部署了crm

nginx + uwsgi + django + virtualenv + supervisor + mariadb
專案賬密:alex;alex3714

2.部署一個前后端分離專案

vue(js框架)(nginx回傳vue頁面) + 
django rest freamwork(提供api介面的框架)(后端) +
virtualenv +
sqlite +
redis(k-y型資料庫)(存放課程資訊,登錄的賬號密碼)

`后端部署程序:
	1.準備后端代碼-django
	wget https://files.cnblogs.com/files/pyyu/luffy_boy.zip
	2.解壓縮代碼
	unzip luffy_boy.zip
	3.修改django的settings.py組態檔(允許所有主機登錄)
		ALLOWED_hosts = ["*"]
	4.由于這個路飛代碼用的是sqlite,所以不需要配置mysql資料庫了
	5.創建路飛專案的虛擬環境,運行代碼
		mkvirtualenv s19luffy_boy
	6.解決路飛運行,所需模塊依賴
		pip3.6 freeze >> requitements.txt #匯出模塊的命令
		#提示
		#我已經給你準備好了這個檔案的資訊
		......略
	7.安裝uwsgi, 運行路飛的后端,支持多行程的django
	#命令運行方式
    uwsgi --http : 8000 --module luffy_boy.wsgi
    #組態檔方式如下
    vim uwsgi.ini

	#寫入如下內容:
        [uwsgi]
        # Django-related settings
        # the base directory (full path)
        # 填寫你專案的絕對路徑,第一層
        chdir    = /opt/s19luffy/luffy_boy
        # Django's wsgi file
        # 找到django的那個我wsgi.py檔案
        # 根據上面一條引數,的相對路徑來寫
        module   = luff_boy.wsgi
        # the virtualenv (full path)
        # 虛擬環境的絕對路徑
        home     = /root/Envs/s19luffy_boy
        # process-related settings
        # master 主行程
        master   = true
        # maximum numver of worker processes
        # 根據你的cpu核數來定義
        processes    = 4
        # the socket (use the full path to be safe
        # 指定你的django啟動在什么地址上并且是什么協議
        # 如果你用了nginx反向代理, 請用socket引數
        socket    =0.0.0.0:9000
        # 如果未使用nginx反向代理, 想要直接使用django, 用這個引數:
        # http = 0.0.0.0:8000
        # ... with appropriate permissions - may be needed
        # chmod-socket    = 664
        # clear environment on exit
        vacuum    =true
        #開啟熱加載
        py_autoreload = 1
        
	8.啟動路飛后端
	uwsgi --ini uwsgi.ini
	
	
`前端部署程序:
	1.準備前端代碼-vue
	wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip
	
	2.解壓縮代碼包
	unzip 01-luffy_project_01.zip
	未更改過的vue代碼,長這樣
        build
        config
        index.html
        package.json(vue包資訊)
        package-locak.json
        README.md
        src
        static`
    3.下載nodejs解釋器,用于編譯vue代碼
    
    4.解壓縮node的源代碼包
    node如同python3.6是一個解釋器
    npm如同pip是一個包管理工具
    
    5.配置node的環境變數PATH
    寫入path中:/opt/s19luffy/node-v8.6.0-linux-x64/bin
    	修改vue向后臺發送地址的介面, 必須修改...
    	批量替換介面地址
    	sed -i "s/127.0.0.1:8000192.168.43.157:8500/g" api.js
    	sed #處理文本資訊的命令
    	-i 將替換結果插入到文本中
    	s/你想替換的內容/替換之后的內容/global全域替換
 
    	
    	
    	
    6.安裝vue模塊
    npm install
    7.模塊安裝完畢后,進行編譯打包,生成dist靜態檔案夾
    8.編譯打包vue完成之后,會生成一個dist靜態檔案夾,里面存放了路飛首頁所有內容,交給nginx即可

nginx配置如下:

1.支持vue的頁面虛擬主機

location / {
    root /opt/s19luffy/07-luffy_project_01/dist;
    index index.html
        try_files $url $url/ /index.html;
    	#保證首頁重繪不出現404
}

2.反向代理的虛擬主機

server {
    listen 8500;
    server_name192.168.43.157;
    location / {
        uwsgi_pass 192.168.43.157:9000;
        include uwsgi_params
    }
}

安裝啟動redis資料庫

1.通過yum簡潔的安裝

yum install redis -y

2.通過yum安裝的軟體如何啟動

systemctl start redis

3.可以查看redis資料庫資訊

redis-cli 登陸資料庫

4.查看購物車資訊

key *

mariadb就是centos下的mysql,開源免費,用法與mysql是一模一樣

1.阿里云的yum倉庫和mariadb的yum倉庫,其實就是兩個不同的url提供了2兩不同的yum倉庫,軟體版本可能較低,不會實時更新.如果你要

如果選擇阿里云的yum倉庫,安裝命令如下

yum install mariadb-server mariadb -y

如果你要選擇最新的mariadb軟體,請配置官方yum源

安裝命令如下

yum install mariaDB-server MariaDB-client

2.安裝好mysql之后就可以啟動使用了,注意要先初始化資料庫

mysql_secure_installation

3.學習mysql的授權命令

允許mysql服務端可以遠程連接的命令
grant all privileges on *.* to root@'%' identified by '168168956';
#允許root用戶在任意的主機地址都可以登錄mysql服務端

flush privileges;
#立即重繪權限表

# 引數說明：
ALL PRIVILEGES表示賦給遠程登錄用戶的權限，ALL PRIVILEGES表示所有的權限，可以單獨或組合賦select,update,insert,delete權限；

.：第一個*表示要賦權的資料庫名，表示全部資料庫了，第二個表示資料庫下的表名，同理，*表示全部表，也可以根據需求限制表；

sariel表示要賦權的用戶；

%表示遠程登錄的IP，如果要限制登錄IP的話，這里就添允許登錄的IP，比如192.18.1.99等，%表示不限制IP）；

000000是用戶遠程登錄的密碼，
————————————————
著作權宣告：本文為CSDN博主「gblfy」的原創文章，遵循CC 4.0 BY-SA著作權協議，轉載請附上原文出處鏈接及本宣告，
原文鏈接：https://blog.csdn.net/weixin_40816738/article/details/124766572

4.客戶端遠程登錄服務端的命令

mysql -uroot -p -h 192.168.43.157

5.mysql的備份與恢復

#備份
mysqldump -u root -p --all-databases > /opt/alldb.sq
#恢復
1.mysql -uroot -p < /opt/alldb.sql
2.登錄mysql之后,source讀取db檔案
-----------------------------------------
高版本匯出的資料庫和低版本無法兼容會報這個錯誤:
Unknown collation: 'utf8mb4_0900_ai_ci'

mysql主從同步的配置

1.環境準備,兩臺linux,分別安裝好mariadb兩臺資料庫

2.先從master主庫開始配置

1.先停止資料庫服務
systemctl stop mariadb
2.修改mysql組態檔(/etc/my.cnf.d/server.cnf),支持binlog日志
server-id=1
log-bin=s19-bin-log

洗掉軟體時一定要洗掉干凈,直接yum remove無法洗掉干凈會會很麻煩
mariadb啟動報錯也有可能是組態檔導致,my.cnf

3.重啟mysql組態檔,支持binlog日志

server-id=1
log-bin=s19-bin-log

4.重啟mysql資料庫,讓binlog日志檔案生效

systemctl restart mariadb

5.創建一個用戶,用于主從同步

create user 's19'@'%' identified by '168168956';
s19是用戶名
%是允許所有ip登錄
168168956是密碼

6.給這個賬號授予復制的權限

grant replication slave on *.* to 's19'@'%';

7.匯出當前資料庫,發送給從庫,保證資料一致

mysqldump -uroot -p --all-databases > /opt/mydb.sql

從庫配置如下:

1.修改mysql組態檔,加上身份id, vim /etc/my.cnf

[mysqld]
server-id=10
read-only=true

2.重啟從庫的mysql

systemctl restart mariadb

3.從庫匯入主庫的資料,保證起點一致性

4.配置主從同步的關鍵引數

change master to master_host='192.168.43.157',
master_user='s19', #用于同步的資料庫用戶
master_password='168168956', #密碼
master_log_file='s19-bin-log.000001', #指定主庫的日志檔案
master_log_pos=564;

5.開啟主從同步

start slave

6.查看主從同步的狀態

show slave status\G

7.去主庫寫入資料,查看從庫的實時資料同步

redis(NoSQL)(not only sql)

mysql關系型資料庫,檔案型資料庫

redis資料庫學習(nosql 不僅僅是sql),記憶體型資料庫

1.redis的安裝方式, yum安裝, 原始碼編譯安裝

查看是否用yum安裝了redis
rpm -qi redis

2.選擇原始碼編譯安裝redis 需要先卸載redis(yum安裝的)

yum remove redis -y

3.下載redis的源代碼, 編譯安裝, 指定安裝路徑

wget http://download.redis.io/releases/redis-4.0.10.tar.gz

4.解壓縮源代碼,編譯安裝

tar -zxvf redis-4.0.1.tar.gz
進入源代碼目錄,開始編譯安裝
這里不需要configure,直接make&&make install
直接裝在了當前的redis原始碼目錄下,組態檔,啟動命令,都在當前目錄下了
/opt/redis-4.10.0/redis.conf
因為源代碼包以及有Makefile檔案了

redis的可執行命令如下,解釋:

./redis-benchmark //用于進行redis性能測驗的工具
./redis-check-dump //用于修復出問題的dump.rdb檔案
./redis-cli //redis的客戶端
./redis-server //redis的服務端
./redis-check-aof //用于修復出問題的AOF檔案
./redis-sentinel //用于集群管理

5.如何安全的啟動redis

? 1.更改默認的redis啟動埠

? 2.給redis啟動添加密碼

? 3.開啟redis的安全機制(必須用密碼驗證,才能登陸資料庫)

修改redis.conf組態檔內容

bind 0.0.0.0 #redis系結的地址
protected-mode yes #redis安全模式
port 6379 #redis的埠
daemonize yes #后臺運行redis
requirepass 168168956 #redis的密碼

6.指定redis組態檔啟動資料庫

redis-server redis.conf

7.指定埠和主機登錄

redis-cli -p 6379 -h 192.168.43.157
登錄之后,通過auth指令驗證碼
auth 168168956
#在登錄命令中添加密碼
redis-cli -p 6379 -h 192.168.43.157 -a 168168956

8.遠程python連接python服務端

import redis
conn = redis.Redis(host='192.168.43.157', port=6379, password='168168956')
conn.set('name', 'zzy')
>>>True
conn.get('name')
>>>b'zzy'

9.redis的資料庫型別使用

redis是一種高級的key:value存盤系統, 其中value支持資料型別:
	字串(strings):
		set key value # 設定name為key,值是apple
		set name apple #設定name的值
		get name #獲取name的值
		append name "zzy"#追加string
		mset name1 zzy name 2 wxy name3 hhx #設定多個鍵值對
		mget name1 name2 name3#獲取多個鍵值對
		del name#洗掉key
		incr #遞增+1
		decr #遞增-1
		
	散列(hashes): 字典key-value:
		 hset #設定為散列值
		hget # 獲取散列值
		hmset #設定多對散列值
		hmget #獲取多對散列值
		hsetnx #如果散列已經存在,則不設定(防止覆寫key)
		hkeys #回傳所有keys
		hvals #回傳所有values
		hlen #回傳散列包含的域(field)的數量
		hdel #洗掉散列指定的域(field)
		hexists #判斷是否存在
	串列(lists):
		lpush list 1 2 3 4 5 #從串列左邊插
		rpush list 5 4 3 2 1 #從串列右邊插
		lrange list 0 -1 #獲取一定長度的元素(start end)
		ltrim list 0 2 #截取一定長度串列(0,1,2)
		lpop #洗掉最左邊一個元素
		rpop #洗掉最右邊一個元素
		lpushx/rpushx #key存在則添加值,不存在不處理
		
	集合(sets): 無序去重的資料型別
		sadd/srem #添加/洗掉元素
			sadd set 1 2 3 4
			srem set 1 2 3 4
		sismember set #判斷是否為set的一個元素
		smembers set #回傳集合所有成員
		sdiff set set2 #回傳一個集合和其他集合的差異
		sinter set set2 #回傳幾個集合的交集
		sunion set set2 #回傳幾個集合的交集
	有序集合(sorted sets):
		#都是以z開頭的命令
		zadd mid_test 70 "alex" #添加有序集合
		zrange score 0 -1 #升序
		zrevrange score 0 -1 #逆序
		zrank score  zzy #查看有序集合里任意成員排名
	
	keys * # 查看機器所有的key
	type key # 顯示key的型別
	expire key # 給key加上過期時間
	ttl key # 查看key的剩余過期時間 -1永不過期 -2代表key不存在
	persist # 取消key的過期時間
	exists key # 檢測key是否存在 1存在 0不存在
	del key # 洗掉key
	dbsize # 計算key的數量

演示板

#為結果
127.0.0.1:6379> lpush paidui jay she yanzi zzy wuyuetian sudalv hebe
#(integer) 7
127.0.0.1:6379> lrange paidui 0 -1

#1) "hebe"
#2) "sudalv"
#3) "wuyuetian"
#4) "zzy"
#5) "yanzi"
#6) "she"
#7) "jay"
lpush總是last push的值在最上面也是最前面
rpush總是first push的值在最上面也是最前面

Pub/Sub(發布/訂閱)-redis發布訂閱

psubscribe
publish
pubsub
punsubscribe
subscribe
unsubscribe

redis的資料持久化

背景: 行程被殺死,服務器斷電,記憶體中資料被殺死資料都會釋放,資料丟失,如果redis沒有持久化,資料丟失

1.redis支持兩種資料持久化

AOF(append-only log file): 記錄服務器執行的所有變更操作命令(例如 set del等),并在服務器啟動時,通過重新執行這些命令還原資料集
優點: 最大程度保證資料不丟
確定: 日志記錄非常大

AOF持久化模式:
	1.在組態檔中定義功能引數即可使用aof:
	daemonize yes
    port 6379
    logfile /data/6379/redis.log
    dir /data/6379
    appendonly yes
    appendfsync everysec
	2.指定aof組態檔啟動:
	redis-server s19-aof.conf
	3.啟動redis服務端,查看aof日志變動,并且aof資料持久化
	

RDB: 定期自動或手動執行把redis記憶體中的資料保存在磁盤上的一個二進制檔案中,redis可以通過這個檔案還原當時資料庫的狀態.類似于快照
	1.基于記憶體快照的持久化
	  持久化資料是個壓縮的二進制檔案
	  通過save指令可以手動出發持久化
	  也可通過配置時間出發持久化
	  
redis.conf:
	port 6379
    daemonize yes
    logfile /data/6379/redis.log
    dir /data/6379 #資料存放地址
    dbfilename dbmp.rdb
    bind 0.0.0.0

    save 900 1
    save 300 10
    save 60 10000
    
創建資料檔案夾:
	mkdir -p /data/6379
3.指定支持持久化的redis組態檔啟動:
	redis_server s19-rdb.conf

4.測驗寫入redis資料:
	set name haha
	save #觸發持久化
	此時就會生成一個dump.rdb資料檔案在/data/6379目錄

5.此時就算重啟 資料也不會丟失:
	注意必須指定組態檔啟動
rdb有缺點,可能會造成資料丟失,但是持久化速度最快

問答

'reids持久化方式有哪些?有什么區別?

	rdb: 基于快照的持久化,速度更快,一般用作備份,主從復制也是依賴于rdb持久化功能
	aof: 一追加方式記錄redis操作日志檔案.可以最大程度保證redis資料安全類似于mysql的binlog
	
'redis不重啟,切換RDB備份到AOF備份'
	確保redis版本在2.2以上,通過config set 命令,達到不重啟redis服務,從rdb持久化切換到AOF
	1.實驗準備:
		rdb的redis資料庫寫入資料
	2.在登陸了rdb的資料庫當中進行切換aof命令如下:
	
	3.配置aof的方式如下,通過config set命令設定aof的功能:
		127.0.0.1:6379> config set appendonly yes
         OK
         127.0.0.1:6379> config set save ""
         OK
     4.還得修改組態檔,以后再次開啟服務永遠都是aof:
     	vim s19-rdb.conf
     	'''
     	appendonly yes
     	appendfsync everysec
     	'''
		
		

redis的主從同步功能

1.redis支持多實體的功能,通過組態檔生效,多實體的概念

寫多個組態檔,指定檔案啟動,埠區分資料庫,就是多實體了.

redis-6379.conf 主庫

port 6379
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dbfilename dump.rdb
dir /data/6379
protected-mode no

redis-6380.conf 從庫1

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 0.0.0.0:6379

redis-6381.conf 從庫2

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no
slaveof 0.0.0.0:6379

創建資料檔案夾:

mkdir -p /data/{6379,6381,6381}

分別啟動三個redis資料庫實體,默認已經是主從關系了

redis-server redis-6379.conf
redis-server redis-6380.conf
redis-server redis-6381.conf

檢查redis的主從關系

redis-cli -p 6379 info repliction
redis-cli -p 6380 info repliction
redis-cli -p 6381 info repliction

redis的主從復制故障修復

現在是1主2從的狀態,假設6381掛掉了有沒有影響?
1.手動殺死主庫:
	kill調
2.選擇一個從庫為新的主庫,例如6380是主,6381是從:
	登錄6380資料庫,輸入:
		slaveof no one
3.去登陸6381從庫,s:
	slaveof no one

redis高可用之哨兵功能

Redis-Sentinel:
	當用redis作master-slave的高可用時,如果master本身宕機,redis本身或客戶端都沒有實作主從切換的功能
	
而redis-sentinel就是一個獨立運行的行程,用于監控多個mster-slave集群,
自動發現master宕機,進行自動切換slave > master
sentinel主要功能如下:
	不時的監控redis是否良好運行,如果節點不可達就會對節點進行下線表示
	如果被標識的是主節點,sentinel就會和其他的sentinel節點"協商", 如果其他節點也為主節點不可達, 就會選舉一個sentinel節點來完成自動故障轉義.
	在master-slave進行切換回, master_redis.conf, slave_redis.conf和sentinel.conf的內容都會發生改變,即master_redis.conf中會多一行slaveof的配置, sentinel.conf的監控目標會隨之調換
----------------------------------------------------
sentinel實際上就是保安(也可以有多個)來檢測你的redis是否掛調

1.配置哨兵sentinel功能

#環境準備
三個redis實體,準備一主兩從的架構

redis-6379.conf:
'''
port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/opt/data/6379" #要先建立資料檔案哦
'''
--------------------------------------------------
redis-6380.conf
'''
port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/opt/data/6380"
slaveof 0.0.0.0 6379
'''
--------------------------------------------------
redis-6381.conf
'''
port 6381
daemonize yes
logfile "6381.log"
dbfilename "dump-6381.rdb"
dir "/opt/data/6381"
slaveof 0.0.0.0 6379
'''
--------------------------------------------------

分別啟動三個redis資料庫
檢查三個redis身份資訊
redis-cli -p 6379 info replication
...
...
---------------------------------------------------
三個redis-sentinel組態檔,運行三個哨兵行程
redis-sentinel-26379.conf
配置如下,其他節點僅僅是埠的不同
'''
port 26379
dir /opt/data/26379
logfile "26379.log"
sentinel monitor s19msredis 0.0.0.0 6379 1
sentinel down-after-millisecondas s19msredis 30000
sentinel parallel-syncs s19msredis 1
sentinel failover-timeout s19msredis 180000
daemonize yes #后臺運行
'''
----------------------------------------------------
分別啟動三個哨兵
redis-sentinel redis-sentinel-26379.conf
redis-sentinel redis-sentinel-26380.conf
redis-sentinel redis-sentinel-26381.conf
----------------------------------------------------
'此時驗證redis
redis-cli -p 26379 info sentinel#查看哨兵是否成功
'出現如下資訊則正確:
master0:name=s19msredis,status=ok,address=0.0.0.0:6379,slaves=2,sentinels=3

查看redis主庫,查看是否會自動的主從故障切換

redis-cluster集群搭建

1.環境準備6個redis節點配置
redis-7000.conf
redis-7001.conf
redis-7002.conf
redis-7003.conf
redis-7004.conf
redis-7005.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
'''
----------------------------------------------------------
分別啟動6個節點
redis-server redis-7000.conf
......

此時redis的集群還未分配槽位slots,我們需要下載ruby的腳本,創建這個16384個槽位分配

安裝ruby

1.下載ruby的原始碼包
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz

2.解壓縮原始碼包目錄
tar -zxvf ruby-2.3.1.tar.gz

3.進入ruby原始碼包目錄
./configure --prefix="/opt/ruby"
make && make install
4.配置ruby的環境變數
PATH=""
5.讀取PATH環境變數
source /etc/profile

6.下載ruby的包管理工具gem
#ruby安裝操作reedis的包模塊
gem install -l redis-3.3.0.gem

7.一句命令分配redis集群的槽位(*)
--replicas 1這個意思是每一個主庫,只有一個從庫
這個redis-trib.rb命令, 默認不會添加環境變數,直接用絕對路徑去創建,
find /opt -name redis-trib.rb #查看這個腳本的絕對路徑
/opt/redis-4.0.10/src/redis-trib.rb create --replicas 1 0.0.0.0:7000 0.0.0.0:7001 0.0.0.0:7002 0.0.0.0:7003 0.0.0.0:7004 0.0.0.0:7005


8.此時槽位以及分配好了,此時可以寫入集群資料了
登錄某一個節點,寫入資料,查看結果
redis-cli -p  7000 -c  #以集群方式運行

tips:如若再次啟動集群需清理 /opt/redis/data/目錄下的快取檔案

Docker

linux的容器技術

*使用go語言撰寫的軟體
*安裝簡單 性能優越
*將應用程式打包在一個容器內,打包在一個檔案里,運行這個檔案就會生成一個虛擬容器

應用場景

web應用程式的自動化和打包發布:
自動化測驗和持續集成,發布:
在服務型環境中部署和調整資料庫或其它應用:

dev 開發

ops 運維

互聯網公司的技術堆疊

老企業(貴):
	java + jquery + oracle(甲骨文資料庫) + redhat(紅帽os) + svn(代碼版本控制) + mencached(快取資料庫) + apache

互聯網企業(省錢)(開源免費軟體):
	python/... + nodejs + vue + centos7 + git + redis + nginx + mysql + rabbitmg +docker
	

vmware虛擬化技術

個人學習版本:
	vmware workstaion(性能較低,只能運行10幾個虛擬機)
企業版本虛擬化:
	vmware svphere(運行esxi虛擬化服務器)
	256GB的物理服務器可以虛擬化出100多個linux
	
缺點:
	虛擬機的局限性,在于每一臺都是完整的作業系統,要分配系統資源. 

docker vs 傳統虛擬機

特性	容器	虛擬機
啟動	秒級	分鐘級
硬碟使用	一般為MB	一般為GB
性能	接近原生	弱
系統支持量	單機支持上千個容器	一般幾十個

解決環境部署問題的辦法:

# 1.虛擬化模板克隆
## docker的三大生命周期(*)
	1.容器
	2.鏡像
	3.倉庫
基于docker鏡像(作業系統鏡像) 運行處 容器實體(作業系統+應用 )
##dvd系統鏡像.iso 


## docker鏡像如同類的關系,基于鏡像運行處容器(類的實體化)
```python
	class Student():
		def __init__(self):
			print('安裝python3')
			print("安裝python模塊依賴")
			print('安裝虛擬環境......')
			print('休息一下')
	s1=Student()
	s2=Student()
	s3=Student()
	s4=Student()
	
	
# docker鏡像 可以在dockerhub下載,也可以通過dockerfile構建鏡像
# docker容器 基于docker鏡像,可以運行出的實體
# docker倉庫 存盤docker鏡像的地方,就是一個倉庫,公網的倉庫是dockerhub,還有私人的倉庫

centos7安裝docker

1.yum安裝,阿里云,騰訊云,清華源,最正確的官方yum倉庫(版本更新,下載很慢)
yum install docker -y
2.啟動docker
systemctl start docker
systemctl status mysql #驗證docker是否啟動
docker --version

3.docker的命令學習,對鏡像,容器的管理命令

1.獲取鏡像

2.運行鏡像

3.對容器進行管理

配置docker加速器,加速鏡像下載查找

curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

#這里還得修改docer的命令
/etc/docker/daemon.json
編輯如下:
'''
{
"registry-mirrors": [
"https://bjtzu1jb.mirror.aliyuncs.com",
"http://f1361db2.m.daocloud.io",
"https://hub-mirror.c.163.com",
"https://docker.mirrors.ustc.edu.cn",
"https://reg-mirror.qiniu.com",
"https://dockerhub.azk8s.cn",
"https://registry.docker-cn.com"
]
}
'''
------------------------------------------------------------
或者:
'''
{
"registry-mirrors" : [
  "https://8xpk5wnt.mirror.aliyuncs.com"
        ]
}
'''

鏡像:
	增刪查
	docker search 鏡像名 #其實是去docker hub搜索鏡像
	
	docker search hello-world #搜索docker鏡像
	
	docker pull hello-world #下載docker鏡像
	
	docker image ls #查看當前機器的docker鏡像
	
	docker images #同上
	-------------------------------------------------
	docker rm 鏡像名/鏡像id #洗掉容器記錄(只能洗掉掛掉的容器記錄)
	docker rm `docker ps -aq` #一次性洗掉所有docker容器記錄,只能洗掉掛掉的記錄
	[利用反引號運行(這條命令的結果)作為引數]
	docker rmi -f 鏡像id #強制洗掉鏡像force
	--------------------------------------------------
	docker run -d centos /bin/sh -c "while true;do echo hello centos; sleep 1;done" # 在后臺運行docker容器
	--------------------------------------------------------
	docker logs 容器id #查看容器內日志資訊
	docker logs -f 容器id # 實時查看重繪容器日志資訊
	--------------------------------------------------------
	docker exec  -it 容器id /bin/bash #用exec指令,進入到容器系統內
	docker exec -it 容器id /bin/bash  #進入一個人已經在運行的docker容器中
	--------------------------------------------------------
	-i	互動式shell的命令方式
	-t 開啟一個終端去運行
	docker run -it ubuntu /bin/bash
	
	
容器:
	增刪改查
	docker run 鏡像名/鏡像id #運行docker鏡像,生成容器記錄
	docker run 不存在的鏡像名 #會先docker pull下載,然后自動運行
	
	docker container ls #列出當前機器的所有容器(正在運行的容器,正在運行的dockee行程)
	docker ps #查看docker行程,docker容器記錄的
	docker ps -a #查看dockers所有的行程,以及掛掉的行程
	
	
'運行一次鏡像,就會生成一個容器記錄
'docker容器必須有正在運行的行程, 否則容器就會掛掉

運行一個centos的docker容器

1.下載docker鏡像,且是centos的鏡像
docker pull centos
2.運行centos鏡像,生成容器
docker run centos #這個容器沒有任何后臺的行程,所以直接掛掉
---------------------------------------------------------
'情景提示,當遇到如下報錯情況,解決方案如下:
'''
[root@localhost docker]# docker run centos
WARNING: IPv4 forwarding is disabled. Networking will not work.
[root@localhost docker]# systemctl restart docker
[root@localhost docker]# docker run centos
[root@localhost docker]# 
'''
----------------------------------------------------------
3.運行一個后臺有行程的容器
docker run -d centos /bin/sh -c "while true;do echo hello centos; sleep 1;done"
    -d damonize 后臺運行的意思
    centos 指定一個鏡像去運行
    /bin/sh 指定centos的解釋器
    -c 指定一段shell語法
    while回圈,然后列印hello centos;每一秒睡眠一次;
    do和done是閉合關系
-------------------------------------------------------------

提交自定義的docker鏡像

1.準備一個centos的docker容器,默認沒有vim的
docker run -it centos /bin/bash/ #c創建啟動一個docker容器,且是centos系統的

2.退出docker容器空間,然后提交這個容器,生成一個新的鏡像檔案
docker commit 你想要提交的容器id 你想要創建的鏡像名

3.查看你創建的鏡像
docker images

4.匯出你提交的鏡像,成為一個壓縮檔案
docker save zzy/s19-centos-vim > /opt/myimage.tar.gz

5.把這個壓縮檔案,傳遞給其他人,其他人匯入這個鏡像檔案,然后運行,默認就攜帶了vim編譯器
docker load < /opt/myimage.tar.gz

運行一個web內容的docker容器

docker run -d -P training/webapp python app.py
	-d 后臺運行
	-p 小寫字母引數意思是指定映射埠: -p 8001:8000
	-P 大寫字母P引數意思是隨機映射一個埠
	
	用戶 xxx.xxx.xxx.xx:8000 --> 我的服務器 xxx.xxx.xxx.xx:8000 如果是直接運行在物理機的8000埠,就直接回應
	用戶 xxx.xxx.xxx.xx:8000 --> 我的服務器 xxx.xxx.xxx.xx:8000 訪問的不再是物理機上的行程而是容器內的行程 --> 容器內的一個行程和埠

dokcerfile的學習

dockerfile的作用是創建一個docker鏡像

1.docker鏡像倉庫下載(不可控制docker鏡像內容)

2.把其他人發來的docker鏡像進行匯入(不可控,鏡像內容也是其他人定制的)

3.dockerfile通過腳本自定義docker鏡像(把部署程序寫入到一個腳本當中,學習dockerfile的指令,去部署即可)

#每一個app運行,必須得有一個系統作為載體
from scratch #制作base image 基礎鏡像,盡量使用官方的image作為base image
from centos #使用base image
from ubuntu:14.04 #帶有tag的base image
-------------------------------------------------------------
label version="1.0" #容器元資訊,幫助資訊,Metadata,類似于代碼注釋
LABEL maintainer="[email protected]" # 告訴別人這個dockerfile是誰寫的
-------------------------------------------------------------
#萬能指令,去執行你輸入的命令
#對于復雜的RUN命令,避免無用的分層,多條命令用反斜杠換行,合成一條命令!
RUN yum update && yum install -y vim \
	Python-dev #反斜杠換行
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME"

# 可以用run指令,告訴docker,去自動的裝哪些程式依賴
WORKDIR /root #相當于linux的cd命令,改變目錄,盡量使用絕對路徑!!!不要用RUN cd
WORKDIR /test #如果沒有就自動創建
WORKDIR demo #在進入demo檔案夾
RUN pwd # 列印結果應該是/tets/demo
-------------------------------------------------------------
ADD and COPY
ADD hello / #把本地檔案添加到鏡像中,把本地的hello可執行檔案拷貝到鏡像的/目錄
ADD指令用于把物理機上的檔案添加到容器空間內,并且還有解壓縮的
作用
ADD /opt/zzy.jpg	/opt/ #把物理機的linux /opt下的一張jpg圖片,傳輸到容器空間內的/opt目錄下
|
|
|
|
ADD 與 COPY
	-優先使用copy
	-add除了copy功能還有解壓功能
copy指令的作用是把物理機的檔案拷貝到容器控制元件內不解壓	

添加遠程檔案/目錄使用curl或wget
|
|
|
ENV #環境變數,盡可能使用ENV增加可維護性
ENV MYSQL_VERSION 5.6 #設定一個mysql常量

RUN yum install -y mysql-server="${MYSQL_VERSION}"#變數

ENV 指令用于定義變數

dockerfile的實際應用,創建一個flask鏡像,基于這個flask鏡像,運行web容器

1.準備flask的代碼
myfalsk.py 內容如下,基于py2運行代碼:
'''
'''
2.準備dockerfile的撰寫
'''
FROM centos #yicentos為基礎作業系統
COPY CentOS-Base.repo /etc/yum.repos.d/ #修改容器內的yum元,把本地的repo檔案,傳輸到容器內的yum倉庫目錄下
COPY epel.repo /etc/yum.repos.d/ #同上,用于安裝yum源
COPY myflask.py /opt/ #把本地的flask代碼檔案,拷貝到容器空間內
RUN yum clean all #讓容器執行這個命令,清空原本的yum快取
RUN yum install python-setuptools -y #centos默認沒人easy_install
RUN easy_install flask #容器自動的執行 安裝flask模塊的命令
WORKDIR /opt #切換容器內的作業目錄
EXPOSE 8080 #開發容器內的8080埠,提供給宿主機去映射
CMD ["python", "s19-flask"] #容器去執行這一段指令
'''

Dockerfile內容:
FROM centos 
COPY CentOS-Base.repo /etc/yum.repos.d/
COPY epel.repo /etc/yum.repos.d/ 
COPY myflask.py /opt/ 
RUN yum clean all 
RUN yum install python-setuptools -y 
RUN easy_install flask 
WORKDIR /opt 
EXPOSE 8080 
CMD ["python", "s19-flask"]
-------------------------------------------------------------
Dockerfile內容(New):
FROM centos:7.8.2003
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo;
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/epel-7.repo;
RUN yum makecache fast;
RUN yum install python-devel python-pip -y
RUN pip install flask
COPY app.py /opt
WORKDIR /opt
EXPOSE 8080
CMD ["python", "app.py"]
-------------------------------------------------------------
編譯遇到問題或者無法解決的bug
poweroff關閉虛擬機
然后再次手動開啟之后ssh連接 2023-02-25 19:30

docker的web應用:

docker run -d -P training/webapp python app.py 運行一個doucker容器行程
#后臺運行一個python web代碼且進行埠映射

查看容器行程, 結果是宿主機的32768埠,映射到了5000埠
[root@localhost ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
66be7f71911b        training/webapp     "python app.py"     2 hours ago         Up 2 hours          0.0.0.0:32768->5000/tcp   distracted_heyrovsky

1.創建,且運行一個web容器
docker run -d -P training/webapp python app.py
2.查看容器的埠映射關系
docker port 容器id

3.訪問宿主機的32768,即可訪問到容器的5000應用
4.啟停這個容器應用
docker start 容器id
docker stop 容器id

5.指定埠映射關系
docker run -d -p 8888:5000 training/webapp python app.py
	-p宿主機埠
	
6.修改鏡像名
docker tag 鏡像id 要改的名字

7.臨時不錯,運行docker容器時,添加上名字
docker run --name 容器名	運行鏡像名

8.基于自定義flask鏡像, 生成容器實體

dockerfile指令

from 指定基礎鏡像
maintainer 指定維護資訊, 可以沒有
run 你想讓他干啥(在命令前面加上run即可)
add copy檔案并自動解壓
workdir 設定當前作業目錄類似于cd命令
volumn 設定卷, 掛在主機目錄
expose 開放埠
cmd 指定容器啟動后要干的事情

dockerfile其他指令

copy 復制檔案

env 環境變數

entrypoint 容器啟動后執行的命令

docker build . #構建鏡像檔案
docker build --no-cache -t "鏡像名"

修改容器內web程式頁面

1.重新編碼修復

注意flask的host-port與外部系結的埠一定要一樣

2.進入容器中修復
docker exec -it 容器id/容器名 /bin/bash
修改容器內程式
退出容器重啟容器才可以生效.
exit
docker restart 容器id/name

創建nginx鏡像

1.建立一個目錄存放Dockerfile檔案
	mkdir /learn_docker
2.進入目錄并創建Dockerfile檔案
	cat <<EOF > /learn_docker/Dockerfile
	FROM nginx
	RUN nginx
	RUN echo '<meta charset=utf8> zzy happle nginx' >
	/usr/share/nginx/html/index.html
	EOF
	

docker的私有倉庫

我的dockerhub登陸郵箱/用戶名/密碼

[email protected]

zzym

ZZy168168956

1.下載docker官方提供的私有倉庫鏡像(提供了私有倉庫的功能)
docker run -d \
	-p 5000:5000 \
	-v /opt/data/registry:/var/lib/registry \
	registry
	# -v的作用是, 資料卷掛在,檔案夾映射的關系
	# 類似于埠映射的關系, 打開了兩個作業系統之間的管道
http://192.168.43.157:5000/v2/_catalog 存放資料的API(就是一段提供資料的url)地址
-------------------------------------------------------
docker pull registry #下載私有倉庫鏡像
2.修改docker的組態檔,支持非https的方式上傳鏡像
vim /etc/docker/daemon.json

3.還得修改docker的啟動組態檔
修改如下檔案 /lib/systemd/system/docker.service
vim /lib/systemd/system/docker.service # 編輯這個檔案, 添加如下引數

[Service]
EnvironmentFile=-/run/containers/registries.conf
EnvironmentFile=-/etc/docker/daemon.json

4.重新加載docker服務
systemctl daemon-reload
5.重啟docker服務
systemctl restart docker

6.由于重啟了docker,所有的容器都掛掉了
docker run --privileged=true -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry registry

7.推送本地鏡像檔案到私有倉庫中
docker push 192.168.43.157:5000/s19-registry

8.如何區分私有共有
私有倉庫前面是ip和埠
共有倉庫前面是dockerhub官網的用戶名
-------------------------------------------------------
>運行結果是一串id代表無誤
>如果遇到報錯如下
>dial tcp 192.168.43.157:5000: connect: connection refused
>代表沒有運行也就是沒開放埠
>正確運行網頁顯示結果如下
>{"repositories":["s19-registry"]}
>修改引數可以只修改daemon.json
-------------------------------------------------------

docker的公有倉庫

1.登錄dockerhub,在linux命令列中輸入:

docker login

2.輸入你正確的賬號密碼

3.可以推送到你本地的鏡像檔案,到dockerhub了

注意要保證的image的tag是賬戶名, 如果鏡像名字不對,需要改一下tag

docker tag zzy/my_flask_web		zzym/flask_web
語法是: docker tag 倉庫名 zzy/倉庫名

內容回顧

docker一個容器技術

docker的生命周期,三大概念

容器,鏡像,倉庫

容器是鏡像的實體化

倉庫有dockerhub共有倉庫, docker registory私有倉庫,存放鏡像的地方

常用doker管理鏡像的命令

doker rmi 鏡像id

docker rm 容器id

docker ps -a 顯示出所有運行過的容器記錄

docker ps 查看正在運行的容器行程

docker images 查看所有鏡像檔案

docker container ls 列出所有容器行程

docker pull 鏡像名 在線拉取這個鏡像檔案

docker search 鏡像

docker run -d后臺運行 -p指定埠映射 -P隨機埠映射 -it(互動式開啟一個終端) -v 資料卷掛載(宿主機和容器之間的映射) 鏡像名

docker exec -it 正在運行的容器id 互動式命令操作,進入容器空間

docker logs -f 實時查看容器內日志

docker save 匯出鏡像

docker load 匯入鏡像

docker commit 提交本地容器記錄,保存為一個新的鏡像

docker stop 停止容器

docker start 啟動容器

docker tag 現有名 帶標簽的鏡像名

docker build . 找到當前目錄的Dockerfile 進行構建生成新的鏡像

systemctl start docker 啟動docker

docker push 推送本地鏡像到共有/私有倉庫, 如何區分往哪推, 通過你鏡像名來區分

docker login 登錄dockerhub賬戶

End-Less

訊息佇列

實作了訊息佇列功能的軟體rabbitmq,在linux如何安裝呢

rabbitmq很吃資源, 需要至少2g記憶體

實操

1.配置好yum源

2.下載rabbitmq服務端,erlang編程語言

yum install erlang rabbitmq-server -y

啟動命令: systemctl start rabbitmq-server

3.配置以下rabbitmq的web插件

rabbitmq-plugins enable rabbitmq_management

4.創建rabbitmq的登錄賬號密碼

rabbitmqctl add_user zzy 168168956

5.設定用戶為管理員權限

rabbitmqctl set_user_tags zzy administrator

6.對休息佇列進行授權,可以讀寫

rabbitmqctl set_permissions -p "/" zzy 	".*" ".*" ".*"

7.重啟rabbitmq,讓配置生效

service rabbitmq-server restart #centos6
systemctl rabbitmq-server restart #centos7

8.下載python操作rabbitmq的模塊

pip3 install pika
#注意最新的模塊, 引數傳入方式變了

9.實作生產消費者模型的代碼

no_ack, 不確認回復的代碼機制如下:

生產者.py

import pika
#創建配置.使用rabbitqm用戶名密碼登錄
#去郵局去郵局,必須有身份驗證
credentials = pika.PlainCredentials('zzy','168168956')
#新建連接,這里localhost可以更換為服務器ip
#找到這個郵局,等于連接上服務器
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.43.157',credentials=credentials))
#創建頻道
#建造一個大郵箱,隸屬于這家郵局的郵箱,就是個連接
channel=connection.channel()
#宣告一個佇列,用于接收訊息佇列名字叫做'水滸傳'
channel.queue_declare(queue='水滸傳')
#注意在rabbitmq中,訊息想要發生給佇列,必須經過交換(exchange),初學可以使用空字串交換(exchange=""),它允許我們精確的指定發送給哪個佇列(routing_key=''),引數body值發送的資料
channel.basic_publish(
       exchange='',
       routing_key='水滸傳',
       body='武松一拳打死了兩只小老虎')
print("以及發送了訊息")
connection.close()

消費者.py (可以運行多個消費者)

import pika
#建立與rabbitmq的連接
credentials = pika.PlainCredentials("zzy", "168168956")
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.43.157',credentials=credentials))
channel = connection.channel()
channel.queue_declare(queue="水滸傳")

def callbak(ch, method, properties, body):
   #不確認的機制下, 如果消費走了資料, 且代碼報錯,資料會丟失,正確的應該是確認機制
   #int('hehe')
   print('消費者接收到了任務: %r' % body.decode('utf8'))
#有訊息來臨,立即執行callbak,沒有資訊則夯住,等待訊息
#老百姓開始去郵箱取郵件了,佇列名字是水滸傳
#no_ack機制, 不確認機制 ,消費走了不需要給服務端確認, 服務器直接標記訊息清楚
channel.basic_consume("水滸傳",callbak, True)
#開始消費,接收訊息
channel.start_consuming()

no_ack 機制

no_ack=True
   不確認機制, 不需要給服務端一個確認回復, 服務端直接標記訊息清楚, 有可能造成訊息丟失
no_ack=Flase
   確認機制, 你消費走了資料, 還得給服務端發一個確認回復, 讓給服務端可以正確標記訊息清楚,保證訊息不丟失

一個生產者,多個消費者, 默認是輪詢機制

ack機制

生產者.py

import pika
#創建配置.使用rabbitqm用戶名密碼登錄
#去郵局去郵局,必須有身份驗證
credentials = pika.PlainCredentials('zzy','168168956')
#新建連接,這里localhost可以更換為服務器ip
#找到這個郵局,等于連接上服務器
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.43.157',credentials=credentials))
#創建頻道
#建造一個大郵箱,隸屬于這家郵局的郵箱,就是個連接
channel=connection.channel()
#宣告一個佇列,用于接收訊息佇列名字叫做'水滸傳'
channel.queue_declare(queue='王者榮耀')
#注意在rabbitmq中,訊息想要發生給佇列,必須經過交換(exchange),初學可以使用空字串交換(exchange=""),它允許我們精確的指定發送給哪個佇列(routing_key=''),引數body值發送的資料
channel.basic_publish(
       exchange='',
       routing_key='王者榮耀',
       body='敵人還有5秒鐘到達戰場:')
print("以及發送了訊息")
connection.close()

消費者.py(支持ack)

import pika
#建立與rabbitmq的連接
credentials = pika.PlainCredentials("zzy", "168168956")
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.43.157',credentials=credentials))
channel = connection.channel()
channel.queue_declare(queue="王者榮耀")

def callbak(ch, method, properties, body):
   #int('hehe')
   print('消費者接收到了訊息: %r' % body.decode('utf8'))
#有訊息來臨,立即執行callbak,沒有資訊則夯住,等待訊息
#老百姓開始去郵箱取郵件了,佇列名字是水滸傳
#no_ack=False	代表確認要給服務端,回復訊息
channel.basic_consume("王者榮耀",callbak, False)
#開始消費,接收訊息
channel.start_consuming()

End-less

訊息佇列的持久化

背景: 默認佇列不支持持久化, rabbitmq重啟之后, 所有佇列消失

配置持久化的佇列, 方式如下

1.宣告佇列時,加上持久化的引數

持久化的生產者.py

import pika
#建立和服務端的連接部分
credentials = pika.PlainCredentials('zzy','168168956')
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.43.157',credentials=credentials))
channel=connection.channel()
#宣告一個佇列(創建一個佇列)
#默認此佇列不支持持久化,如果服務器掛掉,資料丟失
#durable=True #開啟持久化, 必須新開啟一個佇列, 原本的佇列已經不支持持久化了
'''
實作rabbitmq持久化條件
delivery_mode=2
使用durable=True宣告queue是持久化
'''

channel.queue_declare(queue='LOL', durable=True)
channel.basic_publish(
       exchange='',
       routing_key='LOL',
       body='made fack',
       properties=pika.BasicProperties(
           delivery_mode=2, #代表訊息是持久的
       )
)
connection.close()

總結一下rabbitmq-server

訊息佇列支持持久化的佇列,和非持久化的佇列

以及訊息的確認機制 ack和no_ack的區別

cmdb(資產管理收集 )

end_less

Saltstack

運行依賴包:

python zeromq pyzmp pycrypto

msgpack-python yaml jinja2

saltstack學習

1.環境準備, 兩臺服務器, 一個是master, 一個是minion

master	192.168.43.157
minion	192.168.43.6

2.在兩臺機器上, 分別配置hosts檔案, 配置本地dns服務器(dnsmasq 小型dns服務器)

因為ip的通信, 不易識別, 其通信較慢, 配置hosts強制的本地域名決議, 通信方便

vim /etc/hosts
分別在兩臺機器下輸入如下內容:
'''
192.168.43.6 minion
192.168.43.157 master
'''

關閉防火墻策略,以及關閉服務 (selinux 內置的linux防火墻)(IP tables是軟體防火墻) (硬體防火墻 )
iptables -F #清空規則
systemctl stop firewalld #關閉網路服務器

3.在兩臺機器上, 分別配置好yum源, 下載saltstack軟體

`在master機器上:
yum install satl-master -y
`在minion機器上:
yum install salt-minion -y

4.分別修改兩個軟體的組態檔,需要互相指定對方

編輯master的組態檔, 這個組態檔是yaml語法的,不得有任何錯誤,以及無用空格

vim /etc/salt/master
把如下引數的注釋符刪掉

interface: 0.0.0.0
publish_port: 4505
user: root
ret_port: 4506
pidfile: /var/run/salt-master.pid
worker_threads: 5
ssh_log_file: /var/log/salt/ssh

下屬minion的配置如下

vim /etc/salt/minion
把如下引數的注釋符刪掉

master: master
master_port: 4506
user: root
id: master
log_file: /var/log/salt/minion

5.分別啟動master和minion,注意了, salt-minion發送密鑰給master,是在重啟的一瞬間發送的

systemctl start salt-master
systemctl start salt-minion

6.進行master密鑰認證, 管理minion

對密鑰身份進行, 查看匹配

在服務端查看minion密鑰資訊

? salt-key -f master

在客戶端minion查看自己的密鑰資訊

? salt-call --local key.finger

?

[root@master /]# salt-key -L
Accepted Keys:
Denied Keys:
Unaccepted Keys:
master
Rejected Keys:

salt-key -a minion #接受下屬的密鑰資訊

遇事不決就重啟

7.salt命令

salt-key 	-L #列出所有主機秘鑰資訊
salt-key	-a #接收一個密鑰id

常用引數
-A	#允許所有
-D	#洗掉所有
-a	#認證指定的key
-d	#洗掉指定的key
-r	#注銷指定的key(該狀態為未被認證)

# 星號代表目標匹配字串中(所有的被管控機器)
salt "*"	cmd.run	"你要遠程執行的命令"
salt "你要匹配的minion的id"	cmd.run "命令"

salt "你要匹配的minion的id"	test.ping #檢測機器是否存活
salt --out=json "*" test.ping #以json資料回傳輸出結果
salt "*" test.fib 50 #讓所有的從機器,計算50以內斐波那契值
----------------------------------------------------
salt提供了安裝軟體的模塊命令, pkg模塊就是呼叫的yum工具
salt 'slave' pkg.insatll "nginx" #所有的從機器就會執行yum install nginx
----------------------------------------------------
salt的遠程管理模塊
此模塊呼叫的是yum安裝的軟體命令,并非自己編譯安裝的軟體的命令
salt '*' service.satrt 'nginx' #告訴從機器執行`systemctl start nginx`
salt '*' service.stop 'nginx' #告訴從機器執行`systemctl stop nginx`
----------------------------------------------------
指定salt命令的輸出格式
salt --out=json	'*'	cmd.run "hostname" #輸出json資料可以反序列化
salt --out=YAML	'*'	cmd.run "hostname"#s

linux的shebang	代表代碼宣告	例如
#!usr/bin/python

寫出你見過的組態檔格式

.cnf

.conf

.ini

.cfg 組態檔

.xml java常用

.yml 用的yaml語法的組態檔

.json

yaml語法

語法規則
	大小寫敏感
	使用縮進表示層級關系
	縮進時禁止使用tab鍵,只能空格
	縮進的空格數不重要,相同層級是元素左側對其即可
	#表示注釋行
yaml支持的資料結構
	物件: 鍵值對,也稱作映射......key: value冒號后必須有
	陣列:一組按次序排列的值,又稱為序列
	純量:單個不可再分的值
	物件:鍵值對

yaml
   first_key:
	second_key: second_value

python
	{
       'first_key':{
           'second_key':'second_value',
       }
   }

#yaml語法練習
'like':
   '五月天':
       -"怪獸"
       -"阿信"
       -"石頭"
       -"瑪莎"
       -"冠佑"
   '蘇打綠':
       -"吳青峰"
       -"史俊威"
       -"龔鈺琪"
       -"劉家凱"
       -"謝馨儀"
   

End-Less

End-Less

 ###### salt的靜態資料采集值grains, 可以在minion啟動的時候,自動把自己所有的硬體資產資訊,發送給給master

salt --out=json 's19minion' grains.items #列出主機的所有資訊,以json格式顯示

salt  's19minion' grains.items os #列出os的資訊
salt 's19minion' grains.items ipv4 #列出ipv4的資訊

master利用python的api操作兩臺minion關機

import salt
local = salt.client.LocalClient()
local.cmd("*", "cmd.run", ['poweroff'])
# 成功結果如下
{'s19minion2': False, 's19minion': False}

End-Less

linux 安裝pycharm進行圖形化開發

1.獲取pycharm的inux版本

?

?

轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/548306.html

標籤：Linux

上一篇：典型智能濕度控制系統設計

下一篇：一文帶你徹底搞清楚DAS/SAN/NAS