python自動化運維之CMDB篇
視頻地址：復制這段內容后打開百度網盤手機App，操作更方便哦 鏈接:https://pan.baidu.com/s/1Oj_sglTi2P1CMjfMkYKwCQ 提取碼:ifp2
-
CMD是什么以及發揮什么樣的作用
1.1：CMDB架構
文檔使用CMDB部署redis集群來演示
1.2：CMDB核心功能
1、使用CMDB部署的服務，會服務器記錄所有設備信息 ，包括機房，公網IP/私網，集群信息，負責人，連接交換機端口
帶寬，硬盤，CPU內存等信息
2、在CMDB可以對服務管理維護，任意增刪改查
3、CMDB可以配置圖形界面，也可以使用命令終端操作
1.3：CMDB完成的工作
- 選擇安裝哪些集群包
- 推送新的服務器的DNS解析記錄（內網，外網解析，以及DNS domain的C/S同步工作）
- 新添加的服務器自動加入監控系統，包括在監控平台添加新節點
- 生成防火牆規則，以及配置網絡設備相關
二、CMDB的整體業務架構
客戶端服務端架構，使用tcp通訊（不使用ssh）
2.1: 架構簡介
-
c/s模型
-
服務端負責調用數據庫，並且實時和客戶端保持通信
-
客戶端：配置agent端（腳本）在每一台客戶端機器上，agent作為溝通的中間件，讓所有客戶端節點與服務端保持實時聯系
-
網絡通訊：使用的tcp協議，ssh協議數量大了效率低(還需要配置公鑰私鑰
-
數據庫需要設計表結構，存儲客戶端以及部署的服務信息
2.2：部署redis准備
目錄分配：
軟件安裝：/usr/local/redis/ #啟動redis進程
配置文件：/usr/local/etc/redis #redis配置文件
redis存儲目錄：/data/.xxxx #存儲一般單獨分目錄，給定足夠空間，用隱藏目錄是為了安全
日志目錄： /data/log
redis是單線程運行，需要拆分成多個實例來啟動（提升效率）
三、環境配置
基本環境准備，至少3台服務器
-
cmdb服務端
-
redis+cmdb客戶端
-
任意監控系統+cmdb
3.1: 做好cmdb服務端的解析工作
修改/etc/hosts,或者配置named解析。解析cmdb服務端
3.2：配置好python3的環境
yum install python3
3.3：第一台機器服務端配置好mysql server的環境
下載並安裝mysql官方的yum repository
在server01上安裝
[root@localhost ~]# wget -i -c http://dev.mysql.com/get/mysql57-community-release-el7-10.noarch.rpm
[root@localhost ~]# yum -y install mysql57-community-release-el7-10.noarch.rpm
安裝mysql
server01
[root@localhost ~]# yum -y install mysql-community-server
mysql數據庫啟動
server01
[root@localhost ~]# systemctl start mysqld.service
[root@localhost ~]# systemctl status mysqld.service
修改mysql密碼
server01
[root@localhost ~]# grep "password" /var/log/mysqld.log
[root@localhost ~]# mysql -uroot -p
輸⼊入初始密碼，此時不不能做任何事情，因為MySQL默認必須,修改密碼之后才能操作數據庫：
mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY '123456';
下載安裝pymysql庫
server01
接下來 我們在第⼀一台機器器上 安裝⼀一下 python3 需要調⽤用。pymysql 為了了后⾯面 可以操作DB
wget https://files.pythonhosted.org/packages/44/39/6bcb83cae0095a31b6be4511707fdf2009d3e29903a55a0494d3a9a2fac0/PyMySQL-0.8.1.tar.gz
ls
tar -xvzf PyMySQL-0.8.1.tar.gz
cd PyMySQL-0.8.1/
python setup.py install
python3
import pymysql沒問題，說明安裝成功
在server01上安裝FTP服務
yum install vsftpd
service vsftpd start
默認的ftp路徑：/var/ftp/pub/ #將軟件包拷貝到該目錄
為什么需要ftp服務？
1、當需要在客戶端安裝服務時，在服務端下載安裝包安裝
3.4: 在client01和02安裝python3
客戶端只需要安裝python3，不需要安裝pymysql，因為與數據庫通信，是客戶端通過服務端調用數據庫
3.5：在client02安裝nagios
nagios的配置文件后面將由cmdb來生成
host.cfgèdefine server
四、CMDB的mysql數據庫結構
第一張表
第二張表
第三張表
存儲定義類型，如定義redis nginx
結果如下：
建表語句
python使用 pymysql模塊創建sql表格代碼：
#存儲服務器信息
sql = """CREATE TABLE IF NOT EXISTS SERVERS (
SERVER_ID SMALLINT UNSIGNED NOT NULL auto_increment, #服務id
SERVERNAME CHAR(30) NOT NULL, #可以被解析成ip的機器名
INTERNAL_IP CHAR(20) NOT NULL, #ip地址
ONLINE BOOLEAN, 服務器是否在線
PRIMARY KEY(SERVER_ID))""" 主鍵是server—id
cursor.execute(sql)
#存儲進程信息表
sql = """CREATE TABLE IF NOT EXISTS PROCESS (
PROCESS_ID SMALLINT UNSIGNED NOT NULL auto_increment, #安裝軟件的進程id
PROCESS_NAME CHAR(20) NOT NULL, #進程名
SERVER_ID SMALLINT UNSIGNED NOT NULL, 第一張服務器表對應的server-id，進程位於那台服務器上
SERVICE_ID SMALLINT UNSIGNED NOT NULL, 第三張表service表對應的service-id，進程對應的類型
MASTER BOOLEAN, #是否為主，比如redis的主從，其他服務默認應當是主
SLAVE BOOLEAN, #是否為從
PORT SMALLINT UNSIGNED, #端口號
ONLINE BOOLEAN, #是否在線
PRIMARY KEY(PROCESS_ID))"""
cursor.execute(sql)
#存儲服務id表
sql = """CREATE TABLE IF NOT EXISTS SERVICE (
SERVICE_ID SMALLINT UNSIGNED NOT NULL auto_increment,
SERVICE_NAME CHAR(20) NOT NULL,
PRIMARY KEY(SERVICE_ID))"""
cursor.execute(sql)
五、CMDB的菜單代碼模塊
准備
菜單模塊2
異常退出，關閉進程的方法
六、CMDB的C/S模塊和網絡通訊的利用
七、CMDB的子進程代碼模塊
開啟一個子進程
八、CMDB的推送部署模塊
九、CMDB整體聯調
server01-服務器端 |
Client01 |
Client02 |
python cmdb.py #調用 fork.py #自動調用 server.py #自動調用 |
python agent.py #調用 deplogment.py #自動調用 |
Nagios #略 |
安裝數據庫 |
代碼
cmdb.py
環境代碼
#!/usr/bin/python3
#coding: utf8
import os
import pymysql
import fork #調用了fork，fork調用了server
#數據庫初始化，建表函數，創建3張表，記錄信息
def db_init():
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB") #連接cmdb數據庫
cursor = db.cursor()
sql = """CREATE TABLE IF NOT EXISTS SERVERS (
SERVER_ID SMALLINT UNSIGNED NOT NULL auto_increment,SERVERNAME CHAR(40) NOT NULL,
INTERNAL_IP CHAR(20) NOT NULL,
ONLINE BOOLEAN,
PRIMARY KEY(SERVER_ID))"""
cursor.execute(sql)
sql = """CREATE TABLE IF NOT EXISTS PROCESS (
PROCESS_ID SMALLINT UNSIGNED NOT NULL
auto_increment,
PROCESS_NAME CHAR(20) NOT NULL,
SERVER_ID SMALLINT UNSIGNED NOT NULL,
SERVICE_ID SMALLINT UNSIGNED NOT NULL,
MASTER BOOLEAN,
SLAVE BOOLEAN,
PORT SMALLINT UNSIGNED,
ONLINE BOOLEAN,
PRIMARY KEY(PROCESS_ID))"""
cursor.execute(sql)
sql = """CREATE TABLE IF NOT EXISTS SERVICE (
SERVICE_ID SMALLINT UNSIGNED NOT NULL
auto_increment,
SERVICE_NAME CHAR(20) NOT NULL,
PRIMARY KEY(SERVICE_ID))"""
cursor.execute(sql)
db.close()
#定義一個類，數據庫插入數據
class db_insert:
def db_insert_servers(self,servername,internal_ip,online): #往第一張SERVERS表服務器表插入數據
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB") #連接數據庫
cursor = db.cursor()
cursor.execute('insert into SERVERS (SERVERNAME, INTERNAL_IP, ONLINE)VALUES("%s","%s","%d")' % (servername, internal_ip, online)) #執行sql語句
db.commit() #使用python操作數據庫，必須commit后sql語句才能生效
db.close()
def db_insert_process(self, process_name, server_id, service_id, master, slave, port ,online): #往第二張進程信息表插入數據
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
#TODO
cursor.execute('insert into PROCESS (PROCESS_NAME, SERVER_ID, SERVICE_ID, MASTER, SLAVE, PORT, ONLINE)VALUES("%s","%d","%d","%d","%d","%d","%d")' % (process_name, server_id, service_id, master, slave, port ,online))
db.commit()
db.close()
def db_insert_service(self,service_name): #第三張進程類型表，插入進程類型數據
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
cursor.execute('insert into SERVICE (SERVICE_NAME)VALUES("%s")'%(service_name))
db.commit()
db.close()
#定義一個數據庫查詢類
class db_search:
def db_search_servers(self): #查詢第三張表進程類型表
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
cursor.execute('select * from SERVERS')
results = cursor.fetchall() #fetchall獲取sql執行結果
for row in results: #循環遍歷結果存儲到變量中打印
server_id = row[0]
servername = row[1]
internal_ip = row[2]
online = row[3]
print("服務器編號=%d,服務器名=%s,內網地址=%s,是否在線=%d"%(server_id, servername, internal_ip, online))
db.close()
return server_id
def db_search_service(self):
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
cursor.execute('select * from SERVICE') #取出第三張表所有值
results = cursor.fetchall()
for row in results:
service_id = row[0]
service_name = row[1]
print("服務名編號=%d,服務名=%s"%(service_id, service_name))
#比上一個函數多了一個參數，這種方法叫什么?類的重構?
def db_search_service(self, service_name):
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
server_id_list = []
commond = "select * from SERVICE where SERVICE_NAME = '" + service_name + " '" #第三張進程類型表
cursor.execute(commond)
result = cursor.fetchall()
if result:
service_id = result[0][0]
else:
print("未能找到相關服務，請重新確認")
return
commond = "select * from PROCESS where SERVICE_ID = '" + str(service_id) + " '"
cursor.execute(commond)
result = cursor.fetchall()
if result:
for row in result:
server_id_list.append(row[3])
for server_id in server_id_list:
commond = "select * from SERVERS where SERVER_ID = '" + str(server_id) + " '"
cursor.execute(commond)
result = cursor.fetchall()
if result:
server_name = result[0][1]
print(f'{server_name}\n')
return
def db_search_servers_for_agent_verify(self, sql):
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
sql_line = "select * from SERVERS " + sql
print(sql_line)
cursor.execute(sql_line)
results = cursor.fetchall()
if results:
for row in results:
server_id = row[0]
servername = row[1]
internal_ip = row[2]
online = row[3]
print("服務器編號=%d,服務器名=%s,內網地址=%s,是否在線=%d" % (server_id, servername, internal_ip, online))
sql_line = "select * from PROCESS where SERVER_ID = " + str(server_id)
cursor.execute(sql_line)
results = cursor.fetchall()
for row in results:
process_name = row[1]
master = row[4]
slave = row[5]
port = row[6]
print("process_name: %s, master: %d, slave: %d, port: %d" % (process_name, master, slave, port))
db.close()
return process_name, master, slave, port
else:
print("no data")
#檢查服務器是否正常
def check_servername_ping(servername):
cmd_line = "ping -c 1 -W 1 " + servername #使用ping命令檢查
cmd_re = os.popen(cmd_line).readlines()
if 'rrt' in str(cmd_re):
print("機器可以正常PING ok...自動轉換IP入")
ip = cmd_re[0].split()
ip = ip[2].replace("(", "")
ip = ip.replace(")", "")
print(ip)
return ip
else:
print("機器名無法PING通 請重新輸入")
return 1
#檢查服務器是否被注冊
def check_servername(servername):
db = pymysql.connect("192.168.1.228", "root", "Lzq@31508", "CMDB")
cursor = db.cursor()
re_sna = servername
commond = 'select * from SERVERS where SERVERNAME = ' + '"' + re_sna + '"'
cursor.execute(commond)
results = cursor.fetchall()
if not len(results) == 0:
print("服務器已經被注冊")
return len(results)
if __name__ == '__main__': # 相當於主函數⼊⼝
select_level_1 = True
select_level_2 = True
input_Q_A = True
db_init()
fork.process(1) #調用fork.py的process方法，創建一個子進程，創建fork相當於將父進程復制了一份，生成了子進程。然后2個進程同時調用process方法，需要判斷當前是否是子進程再執行
while select_level_1: #死循環，當循環內達到條件時再跳出
i = os.system("clear") #清理屏幕
select_level_1 = input("1:添加新服務器 2:服務器信息查詢 3:服務部署 4:服務查詢 5:新增服務項\n")
if select_level_1 == '1': #輸入1
while select_level_2: #死循環
servername = ''
servername = input("請輸入機器名\n")
re_num = check_servername_ping(servername) #檢查服務器是否正常
re_sna = check_servername(servername) #檢查服務器是否被注冊
if (not re_num == 1) and (re_sna == 0):
internal_ip = re_num
else:
continue
re_online = input("本機器是否已上線？(Y/N) \n") #確認本機是否上線
if re_online == 'Y':
online = 1
t = db_insert()
t.db_insert_servers(servername, internal_ip, online) #數據庫登記服務器信息
print("新服務器已入庫", servername)
skip = input("按任意鍵返回")
break
else:
online = 0 #服務器未上線
t = db_insert()
t.db_insert_servers(servername, internal_ip, online)
print("新服務器已入庫", servername)
skip = input("按任務鍵返回")
break
if select_level_1 == '2': #輸入2，查詢服務器信息
print("服務器信息查詢")
t = db_search()
t.db_search_servers()
skip = input("按任意鍵返回")
if select_level_1 == '3': #輸入3，服務部署
print("服務部署")
while select_level_2: #死循環
#######進程名
while input_Q_A:
os.system("clear")
process_name = input("請輸入進程名\n") #輸入部署的進程名
if process_name == '':
continue
else:
break
###### 進程部署到哪個服務器
while input_Q_A:
os.system("clear")
print("已輸入進程名",process_name)
t = db_search()
max_server_id = t.db_search_servers() #輸出當前最大的服務器id號
print("輸入范圍 1 - %d"%(max_server_id))
server_id = input("請輸入進程希望部署在哪台服務器（選擇服務器編號）\n") #選擇進程部署到哪台服務器
if server_id.isdigit(): #檢查輸入的字符是否是數字
pass
else:
continue
if int(server_id) <= max_server_id and int(server_id) > 0: #檢查輸入的id號是否在可用范圍
break
else:
continue
###### 選擇進程所屬服務類型
while input_Q_A:
t = db_search()
max_server_id = t.db_search_servers()
service_id = input("請輸入進程所屬的服務類型編號\n")
if service_id.isdigit():
pass
else:
continue
if int(service_id) <= max_server_id and int(service_id) > 0:
break
else:
continue
while input_Q_A:
m_s_choice = input("本進程是否存在 主從關系？（Y/N）")
if m_s_choice == '':
continue
if m_s_choice == 'Y':
break
if m_s_choice == 'N':
break
else:
continue
while input_Q_A:
if m_s_choice == 'Y':
master = input("本進程是否為主？(Y/N)")
if master == 'Y':
master = 1
slave = 0
break
if master == 'N':
master = 0
slave = 1
break
else:
continue
else:
break
while input_Q_A:
port = input("請輸入進程的端口號")
if port.isdigit():
pass
else:
print("端口號輸入不合格（0-65535）")
continue
if int(port) <= 0 or int(port) > 65535:
print("端口號輸入不合法（0-65535）")
continue
else:
break
online = 1
t = db_insert()
t.db_insert_process(process_name, int(service_id),int(service_id),int(master),int(slave),int(port),int(online)) #將選擇的進程信息插入到數據庫
print("進程信息錄入完畢")
skip = input("請按任意鍵返回上層菜單")
break
if select_level_1 == '4':
print("查詢服務所在部署的機器")
t = db_search()
service_name = input("請輸入查詢的服務，如redis、nginx\n")
print("查詢結果如下")
t.db_search_service(service_name)
ret = input("任意鍵返回")
if ret:
continue
if select_level_1 == '5':
while select_level_2:
service_name = input("請輸入新的服務名\n")
t = db_insert()
t.db_insert_service(service_name)
print("新服務名已入庫",service_name)
skip = input("按任意鍵返回")
break
else:
select_level_1 = '0'
os.system("clear")
fork.py
父進程記憶的是子進程id，子進程記憶的是父進程id
#!/usr/bin/python3
#coding: utf8
import os
import time
import server #調用server.py
def process(var):
print("current Process (%s) start ..."%(os.getpid()))
pid = os.fork() #創建一個子進程
print(pid)
#判斷pid方式，確定當前在子進程，當在子進程中，開始調用server.server(1)。server.py
if pid < 0: #pid<0，代表主進程
print("error in fork")
elif pid == 0: #pid==0，代表子進程
print("I anm a child process (%s) and my parent process os(%s)"%(os.getpid(),os.getppid())) #getpid是子進程，getppid是父進程
a = 2
while a > 1:
time.sleep(1)
print("sleeping child!!~~~~")
a = a - 1
server.server(1) #調用server.py的server方法，建立socket連接，監聽客戶端訪問。
else:
print("I (%s) created a child process (%s)."%(os.getpid(),pid))
server.py
服務器端跑的腳本
#!/usr/bin/python3
#coding: utf8
import socket
import sys
import cmdb #需要使用cmdb中的類
def server(var):
serversocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #創建服務端socket文件
host = socket.gethostname() #獲取當前主機名
print(host)
port = 9999
serversocket.bind((host, port)) #將端口與主機名綁定
serversocket.listen(5) #開啟監聽端口port
while True:
clientsocket, addr = serversocket.accept() #解析監聽到的客戶端地址，和客戶端socket通信對象
print("連接地址：%s" % str(addr))
ip1 = str(addr)
ip2 = ip1.split(",")
ip = ip2[0].replace("(", "")
t = cmdb.db_search() #創建cmdb.py的db_search類
sql = "where INTERNAL_IP = " + ip
process_name, master, slave, port = t.db_search_servers_for_agent_verify(sql) #查詢客戶端服務器信息
msg = ip + ' ' + process_name + ' ' + str(master) + ' ' + str(slave) + ' ' + str(port)
clientsocket.send(msg.encode('utf-8')) #將查詢到的信息發送給客戶端socker文件
clientsocket.close()
agent.py
客戶端腳本
#!/usr/bin/python3
#coding: utf8
import socket
import os
import sys
import deployment
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #建立客戶端socket文件
host = "192.168.1.227" #服務器端地址
port = 9999
s.connect((host, port)) #與服務器端建立連接
msg = s.recv(1024) #接受服務端返回的數據
s.close()
print(msg.decode('utf-8'))
msg_list = msg.split()
ip = msg_list[0]
process_name = msg_list[1]
master = msg_list[2]
slave = msg_list[3]
port = msg_list[4]
print(ip)
print(process_name)
print(master)
print(slave)
print(port)
res = os.popen("cat /etc/crontab").readlines() #讀取定時任務文件
tof = True
for a in res:
if "/root/python/agent.py" in a:
tof = False
break
if tof:
commond = 'echo " 5 * * * * root /usr/bin/python /root/python/agent.py" >> /etc/crontab' #如果沒有寫入定時任務，往定時任務中加入每5分鍾運行一次agent腳本
os.popen(commond)
os.popen("systemctl restart crond")
t = deployment.deployment_redis() #調用deployment的腳本，創建redis部署對象
r = t.check_demo(1)
r = t.download(1)
r = t.unzip(1)
r = t.re_locate(1)
r = t.config_file_generating(ip, process_name, master, slave, port)
r = t.make_install(1)
r = t.start_redis(1)
deplogment.py
#coding:utf-8
#! /usr/bin/python3
# -*- coding: UTF-8 -*-
import os
import time
class deployment_redis: #定義一個類
def check_demo(self,var):
cmd_line = "ls /usr/local/redis/"
cmd_re = os.popen(cmd_line).readlines() #在linux命令行執行命令，獲取返回結果
if cmd_re:
return
cmd_line ="netstat -tnlp |grep redis1"
cmd_line = os.popen(cmd_line).readline()
if cmd_re:
return
def download(self, var): #下載軟件
# ftp://10.26.100.120/pub/redis.tar.gz and ftp://10.26.100.120/pub/redis.conf
cmd_line = "wget ftp://anonymous@192.168.1.227/pub/redis.tar.gz" #在服務端使用ftp下載
cmd_re = os.popen(cmd_line).readlines()
def unzip(self, var): #解壓軟件
cmd_line = "tar -xvzf redis.tar.gz && rm -rf redis.tar.gz"
cmd_re = os.popen(cmd_line).readlines()
cmd_line = "mv redis-4.0.8 redis"
cmd_re = os.popen(cmd_line).readlines()
def re_locate(self, var): #移動redis目錄
prefix = "/usr/local/"
cmd_line = "mv redis " + prefix
cmd_re = os.popen(cmd_line).readlines()
def make_install(self,var): #安裝
cmd_line = "cd /usr/local/redis ;make"
cmd_re = os.popen(cmd_line).readlines()
cmd_line = "yes|cp ./redis.conf /usr/local/redis/" #yes，拷貝redis配置文件
cmd_re = os.popen(cmd_line).readlines()
def start_redis(self,var): #開啟redis實例
cmd_line = "/usr/local/redis/src/redis-server /usr/local/redis/redis.conf"
cmd_re = os.popen(cmd_line).readlines()
def config_file_generating(self, ip, process_name, master, slave, port): #打開redis配置文件寫入配置,傳遞服務器參數
f = open("redis.conf", "w")
# 關閉打開的⽂件
## REDIS CONFIGS
emp = {'bind':'10.26.100.120\n',\
'port':'50500\n',\
'pidfile' : '/data/.storage/redis/redis_50500m.redis1.pid\n',\
'logfile' : '/data/log/redis/redis_50500m.redis1.log\n' ,\
'dir' : '/data/.storage/redis/\n' ,\
'dbfilename' : 'redis_50500m.redis1.dump.rdb\n' ,\
'slaveof' : 'redis1 50500\n' ,\
'masterauth' : 'Np3jftX7808X\n' }
print(ip)
print(process_name)
print(master)
print(slave)
print(port)
new_ip = str(bytes.decode(ip)).strip("'") #將傳遞的ip參數編碼，寫入到emp字典
str1 = new_ip + '\n'
emp['bind'] = str1
str1 = bytes.decode(port) + '\n'
emp['port'] = str1
#如果是主服務器，就刪掉slaveof這一項 可以添加如果是非
if master == '1':
del emp['slaveof'] #刪除字典的從信息
master = 'm'
str1 = "/data/.storage/redis/redis_" + bytes.decode(port) + bytes.decode(master) + ".redis1.pid" + "\n" #pid文件路徑
emp['pidfile'] = str1
str1 = "/data/log/redis/redis_" + bytes.decode(port) + bytes.decode(master) + ".redis1.log" + "\n" #日志文件路徑
emp['logfile'] = str1
for k, v in emp.items():
print('{v} = {k}'.format(v = v, k = k))
config_str = k + ' ' + v
f.write(config_str) #將emp字典，鍵值對組合成字符串寫入到f對象中，即打開的redis.conf
emp2 = "protected-mode yes\n\
tcp-backlog 511\n\
timeout 0\n\
tcp-keepalive 300\n\
daemonize yes\n\
supervised no\n\
loglevel notice\n\
databases 16\n\
always-show-logo yes\n\
save 900 1\n\
save 300 10\n\
save 60 10000\n\
stop-writes-on-bgsave-error yes\n\
rdbcompression yes\n\
rdbchecksum yes\n\
slave-serve-stale-data yes\n\
slave-read-only no\n\
repl-diskless-sync no\n\
repl-diskless-sync-delay 5\n\
repl-disable-tcp-nodelay no\n\
slave-priority 100\n\
lazyfree-lazy-eviction no\n\
lazyfree-lazy-expire no\n\
lazyfree-lazy-server-del no\n\
slave-lazy-flush no\n\
appendonly no\n\
appendfilename appendonly.aof\n\
appendfsync everysec\n\
no-appendfsync-on-rewrite no\n\
auto-aof-rewrite-percentage 100\n\
auto-aof-rewrite-min-size 64mb\n\
aof-load-truncated yes\n\
aof-use-rdb-preamble no\n\
lua-time-limit 5000\n\
slowlog-log-slower-than 10000\n\
slowlog-max-len 128\n\
latency-monitor-threshold 0\n\
notify-keyspace-events \"\"\n\
hash-max-ziplist-entries 512\n\
hash-max-ziplist-value 64\n\
list-max-ziplist-size -2\n\
list-compress-depth 0\n\
set-max-intset-entries 512\n\
zset-max-ziplist-entries 128\n\
zset-max-ziplist-value 64\n\
hll-sparse-max-bytes 3000\n\
activerehashing yes\n\
client-output-buffer-limit normal 0 0 0\n\
client-output-buffer-limit slave 256mb 64mb 60\n\
client-output-buffer-limit pubsub 32mb 8mb 60\n\
hz 10\n\
aof-rewrite-incremental-fsync yes\n\
"
print(emp2)
prefix = "/data/log/redis/"
cmd_line = "mkdir -p " + prefix #創建redis日志目錄
cmd_re = os.popen(cmd_line).readlines()
prefix = "/data/.storage/redis/"
cmd_line = "mkdir -p " + prefix
cmd_re = os.popen(cmd_line).readlines()
f.write(emp2) #將emp2字符串，即redis其他配置屬性加入到redis.conf
f.close()