docker部署python工程获取财务服务器是否宕机

前言

实时获取财务服务器的状态，如若宕机，及时进行处理，避免影响日常业务运转

python工程代码

目录结构

tree -aCg .
.
├── [root    ]  docker-compose.yml
├── [root    ]  root
└── [root    ]  data
    ├── [root    ]  config.py
    ├── [root    ]  finance_db.py
    ├── [root    ]  monitor.py
    └── [root    ]  setup.py

1 directories, 6 files

python与sqlite3数据库的代码

cat > /data/finance_db.py <<-EOF
#!/usr/bin/env python3

import sqlite3


class CreateDb():

    def __init__(self, physical_machine_ip=None, virtual_machine_ip=None, database_filename=None, database_table=None, create_table=None, insert_table_data=None, update_table_data=None, select_table_data=None, get_table_data_method=None):
        self.physical_machine_ip = physical_machine_ip
        self.virtual_machine_ip = virtual_machine_ip
        self.database_filename = database_filename
        self.database_table = database_table
        self.create_table = create_table
        self.insert_table_data = insert_table_data
        self.update_table_data = update_table_data
        self.select_table_data = select_table_data
        self.get_table_data_method = get_table_data_method
        self.conn = sqlite3.connect(database_filename)
        self.cur = self.conn.cursor()

    def createTable(self):
        self.cur.execute(self.create_table)
        self.conn.commit()

    def insertTableData(self):
        self.cur.execute(self.insert_table_data)
        self.conn.commit()

    def updateTableData(self):
        self.cur.execute(self.update_table_data)
        self.conn.commit()

    def selectTableData(self):
        self.cur.execute(self.select_table_data)
        self.conn.commit()
        get_table_data = self.cur.fetchall()
        return get_table_data     

    def closeDatabase(self):
        self.cur.close()
        self.conn.close()
EOF

配置文件

自行从钉钉上获取机器人的Webhook的url

cat > /data/config.py <<-EOF
post_url="https://oapi.dingtalk.com/robot/send?access_token=xxx"
physical_machine_ip = "192.168.5.9"
virtual_machine_ip = "null"
database_filename = "/data/monitor_finance_machine.db" 
database_table = "monitor_finance_machine" 
create_table = "create table {0} (id int not null, physical_machine_ip char(20), virtual_machine_ip char(20), status char(10), record_time datetime, content varchar(95));" 
EOF

编辑监控py文件

cat > /data/monitor.py <<-EOF
#!/usr/bin/env python3

import sh
import re
import requests
import json
import sys
import sqlite3
import subprocess
import time
from finance_db import CreateDb
import config as cfg

class Monitor():

    def excuteCommand(self, command):
        subp = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        if subp.poll() != 0:
            return subp.stdout.read().decode("gbk").encode("utf-8")
        else:
            return "failure"

    def __init__(self):
        self.post_url = cfg.post_url
        self.physical_machine_ip = cfg.physical_machine_ip
        self.virtual_machine_ip= cfg.virtual_machine_ip
        self.database_filename = cfg.database_filename
        self.database_table = cfg.database_table
        self.create_table = cfg.create_table
        self.server_start_status = "start"
        self.server_stop_status = "stop"
        self.server_content_start = "0% packet loss"
        self.server_content_stop = "packet loss"
        self.server_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

    def createTable(self):
        create_table_sql = self.create_table.format(self.database_table)
        create_table = CreateDb(database_filename=self.database_filename, create_table=create_table_sql)
        create_table.createTable()
        create_table.closeDatabase()

    def getPingInfo(self):
        ping_command = "ping -c 4 {0}".format(self.physical_machine_ip)
        get_ping_info = Monitor().excuteCommand(ping_command)
        return str(get_ping_info, encoding="utf8")

    def selectTableData(self):
        select_table_data_sql = "select * from {0}".format(self.database_table)
        select_table = CreateDb(database_filename=self.database_filename, select_table_data=select_table_data_sql)
        select_table_data = select_table.selectTableData()
        select_table.closeDatabase()  
        return select_table_data

    def insertTableData(self, insert_table_data):
        insert_table = CreateDb(database_filename=self.database_filename, insert_table_data=insert_table_data)
        insert_table.insertTableData()
        insert_table.closeDatabase()        

    def excuteInsertTableData(self, server_status, server_content, server_time):
        select_table_data = Monitor().selectTableData()
        current_server_status = server_status
        get_db_final_server_status = ''
        if select_table_data != []:
            get_db_final_server_status = select_table_data[-1][3]
        insert_table_data= "insert into {0} values({1}, '{2}', '{3}', '{4}', '{5}', '{6}')".format(self.database_table, len(select_table_data) + 1, self.physical_machine_ip, self.virtual_machine_ip, server_status, server_time, server_content)
        if (select_table_data == []) or (current_server_status != get_db_final_server_status):
            Monitor().insertTableData(insert_table_data)
            Monitor().sendMonitorToDingding(current_server_status)

    def sendMonitorToDingding(self, server_status):
        headers = {'Content-Type': 'application/json'}
        sendData = "财务服务器的状态为: {0}".format(server_status)
        data = {
            "msgtype": "text",
            "text": {
                "content": sendData
            }
        }
        requests.post(self.post_url, data=json.dumps(data), headers=headers)   

    def excuteInsertAndMonitorJob(self):
        get_ping_info = Monitor().getPingInfo()
        server_status, server_content = '', ''
        server_time=self.server_time
        if "0 packets received, 100% packet loss" in get_ping_info:
            server_status = self.server_start_status
            server_content = self.server_content_start
        else:
            server_status = self.server_stop_status
            server_content = self.server_content_stop
        try:
            Monitor().createTable()
        except:
            pass
        Monitor().excuteInsertTableData(server_status, server_content, server_time)
EOF

执行监控程序文件

cat > /data/setup.py <<-EOF
#!/usr/bin/env python3

from monitor import Monitor


if __name__ == "__main__":
    monitor = Monitor()
    monitor.excuteInsertAndMonitorJob()
EOF

定时任务

cat > root <<-EOF
# do daily/weekly/monthly maintenance
# min   hour    day     month   weekday command
*/15    *       *       *       *       run-parts /etc/periodic/15min
0       *       *       *       *       run-parts /etc/periodic/hourly
0       2       *       *       *       run-parts /etc/periodic/daily
0       3       *       *       6       run-parts /etc/periodic/weekly
0       5       1       *       *       run-parts /etc/periodic/monthly
*/1       *       *       *       *       /data/setup.py &> /dev/null
EOF

docker-compose启动应用服务文件

cat > docker-compose.yml <<-EOF
version: "3.5"
services:
  monitor:
    image: techsharearea/apline:python3.8
    container_name: monitor
    hostname: monitor
    volumes:
      - ./data:/data:Z
      - ./root:/etc/crontabs/root:ro
    restart: always
    tty: true
 EOF

部署服务

chmod +x /data/*
docker-compose up -d
docker exec monitor crond

结语

… …