Python之路：堡垒机实例以及数据库操作

一、堡垒机前戏

开发堡垒机之前，先学习Python的paramiko模块，该模块基于SSH用于连接远程服务器并执行相关操作。

SSHClient

用于连接远程服务器并执行基本命令

基于用户名密码连接：

   #!/usr/bin/env  python 
  
# --*--coding:utf- 
  8 --*-- 
  
import paramiko 
  
 
  
#创建SSH对象 
  
ssh = paramiko.SSHClient() 
  
# 允许连接不在know_hosts文件中的主机 
  
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 
  
# 连接服务器 
  
ssh.connect(hostname= 
  ' 
  192.168.1.30 
  ', port= 
  22, username= 
  ' 
  wulaoer 
  ', password= 
  ' 
  123456 
  ') 
  
while  
  True: 
  
    NAM = raw_input( 
  ' 
  input: 
  ') 
  
# 执行命令 
  
    stdin, stdout, stderr = ssh.exec_command(NAM) 
  
    # 获取命令结果 
  
    print stdout.read() 
  
 
  
result = stdout.read() 
  
 
  
# 关闭连接 
  
ssh.close() 
 

 
   
   # 
   !/usr/bin/env  python 
   
# 
    --*--coding:utf-8 --*-- 
   
 
   import paramiko 
   
 
   
transport = paramiko.Transport(( 
   ' 
   192.168.1.30 
   ', 22)) 
   
transport.connect(username= 
   ' 
   wulaoer 
   ', password= 
   ' 
   123456 
   ') 
   
 
   
ssh = paramiko.SSHClient() 
   
ssh._transport = transport 
   
 
   
stdin, stdout, stderr = ssh.exec_command( 
   ' 
   df 
   ') 
   
 
   print stdout.read() 
   
 
   
transport.close() 
   
 

 基于公钥密钥连接：

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import paramiko 
  
  
  
private_key = paramiko.RSAKey.from_private_key_file( 
  ' 
  /home/auto/.ssh/id_rsa 
  ') 
  
  
  
 
  # 
   创建SSH对象 
  
ssh = paramiko.SSHClient() 
  
 
  # 
   允许连接不在know_hosts文件中的主机 
  
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 
  
 
  # 
   连接服务器 
  
ssh.connect(hostname= 
  ' 
  192.168.1.30 
  ', port=22, username= 
  ' 
  wulaoer 
  ', key=private_key) 
  
  
  
 
  # 
   执行命令 
  
stdin, stdout, stderr = ssh.exec_command( 
  ' 
  df 
  ') 
  
 
  # 
   获取命令结果 
  
result = stdout.read() 
  
  
  
 
  # 
   关闭连接 
  
ssh.close() 
 

 
   
   # 
   !/usr/bin/env  python 
   
# 
    --*--coding:utf-8 --*-- 
   
 
   import paramiko 
   
 
   
private_key = paramiko.RSAKey.from_private_key_file( 
   ' 
   /home/auto/.ssh/id_rsa 
   ') 
   
 
   
transport = paramiko.Transport(( 
   ' 
   192.168.1.30 
   ', 22)) 
   
transport.connect(username= 
   ' 
   wulaoer 
   ', pkey=private_key) 
   
 
   
ssh = paramiko.SSHClient() 
   
ssh._transport = transport 
   
 
   
stdin, stdout, stderr = ssh.exec_command( 
   ' 
   df 
   ') 
   
 
   
transport.close() 
   
 

SFTPClient

用于连接远程服务器并执行上传下载

基于用户名密码上传下载

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import paramiko 
  
  
  
transport = paramiko.Transport(( 
  ' 
  192.168.1.30 
  ',22)) 
  
transport.connect(username= 
  ' 
  wulaoer 
  ',password= 
  ' 
  123 
  ') 
  
  
  
sftp = paramiko.SFTPClient.from_transport(transport) 
  
 
  # 
   将location.py 上传至服务器 /tmp/test.py 
  
sftp.put( 
  ' 
  /tmp/location.py 
  ',  
  ' 
  /tmp/test.py 
  ') 
  
 
  # 
   将remove_path 下载到本地 local_path 
  
sftp.get( 
  ' 
  remove_path 
  ',  
  ' 
  local_path 
  ') 
  
  
  
transport.close() 
 

 基于公钥密钥上传下载

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import paramiko 
  
  
  
private_key = paramiko.RSAKey.from_private_key_file( 
  ' 
  /home/auto/.ssh/id_rsa 
  ') 
  
  
  
transport = paramiko.Transport(( 
  ' 
  192.168.1.30 
  ', 22)) 
  
transport.connect(username= 
  ' 
  wulaoer 
  ', pkey=private_key ) 
  
  
  
sftp = paramiko.SFTPClient.from_transport(transport) 
  
 
  # 
   将location.py 上传至服务器 /tmp/test.py 
  
sftp.put( 
  ' 
  /tmp/location.py 
  ',  
  ' 
  /tmp/test.py 
  ') 
  
 
  # 
   将remove_path 下载到本地 local_path 
  
sftp.get( 
  ' 
  remove_path 
  ',  
  ' 
  local_path 
  ') 
  
  
  
transport.close() 
 

 
   
   # 
   !/usr/bin/env  python 
   
# 
    --*--coding:utf-8 --*-- 
   
 
   import paramiko 
   
 
   import uuid 
   
 
   class Haproxy(object): 
   
     
   def  
   __init__(self): 
   
        self.host =  
   ' 
   192.168.1.30 
   ' 
   
        self.port = 22 
   
        self.username =  
   ' 
   wulaoer 
   ' 
   
        self.pwd =  
   ' 
   123456 
   ' 
   
        self. 
   __k = None 
   
 
   
     
   def create_file(self): 
   
        file_name = str(uuid.uuid4()) 
   
        with open(file_name, 
   ' 
   w 
   ') as f: 
   
            f.write( 
   ' 
   dn 
   ') 
   
         
   return file_name 
   
 
   
     
   def run(self): 
   
        self.connect() 
   
        self.upload() 
   
        self.rename() 
   
        self.close() 
   
 
   
     
   def connect(self): 
   
        transport = paramiko.Transport((self.host,self.port)) 
   
        transport.connect(username=self.username,password=self.pwd) 
   
        self. 
   __transport = transport 
   
 
   
     
   def close(self): 
   
 
   
        self. 
   __transport.close() 
   
 
   
     
   def upload(self): 
   
         
   # 
    连接，上传 
   
        file_name = self.create_file() 
   
 
   
        sftp = paramiko.SFTPClient.from_transport(self. 
   __transport) 
   
         
   # 
    将location.py 上传至服务器 /tmp/test.py 
   
        sftp.put(file_name,  
   ' 
   /home/wulaoer/wwwwwwwwww.py 
   ') 
   
 
   
     
   def rename(self): 
   
 
   
        ssh = paramiko.SSHClient() 
   
        ssh._transport = self. 
   __transport 
   
         
   # 
    执行命令 
   
        stdin, stdout, stderr = ssh.exec_command( 
   ' 
   mv /home/wulaoer/wwwwwwwwww.py /home/wulaoer/lllllllllll.py 
   ') 
   
         
   # 
    获取命令结果 
   
        result = stdout.read() 
   
 
   
 
   
ha = Haproxy() 
   
ha.run() 
   
 

二、堡垒机的实现

实现思路：

堡垒机执行流程：

1、管理员为用户在服务器上创建帐号（将公钥放置服务器，或者使用用户名密码）

2、用户登录堡垒机，输入堡垒机用户名密码，现实当前用户管理的服务器列表

3、用户选择服务器，并自动登录

4、执行操作并同时将用户操作记录 

 注：配置.brashrc实现ssh登录后自动执行脚本，如：/usr/bin/python /home/wulaoer/menu.py

实现过程

步骤一，使用用户登录

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import getpass 
  
 
  
user = raw_input( 
  ' 
  username: 
  ') 
  
pwd = getpass.getpass( 
  ' 
  password: 
  ') 
  
 
  if user ==  
  ' 
  wulaoer 
  '  
  and pwd ==  
  ' 
  123 
  ': 
  
     
  print  
  ' 
  登陆成功 
  ' 
  
 
  else: 
  
     
  print  
  ' 
  登陆失败 
  ' 
 

 步骤二，根据用户获取相关服务器列表

   dic = { 
  
     
  ' 
  laowu 
  ': [ 
  
         
  ' 
  172.16.103.189 
  ', 
  
         
  ' 
  c10.puppet.com 
  ', 
  
         
  ' 
  c11.puppet.com 
  ', 
  
    ], 
  
     
  ' 
  wu 
  ': [ 
  
         
  ' 
  c100.puppet.com 
  ', 
  
    ] 
  
} 
  
 
  
host_list = dic[ 
  ' 
  laowu 
  '] 
  
 
  # 
  用户可以连接的主机IP 
  
 
  print  
  ' 
  please select: 
  ' 
  
 
  for index, item  
  in enumerate(host_list, 1): 
  
     
  print index, item 
  
 
  # 
  循环可以连接的主机 
  
inp = raw_input( 
  ' 
  your select (No): 
  ') 
  # 
  选择要连接的IP 
  
inp = int(inp) 
  
hostname = host_list[inp-1] 
  # 
  连接的主机IP 
  
port = 22 
 

 步骤三，根据用户名、私钥登录服务器

   tran = paramiko.Transport((hostname, port,)) 
  
 
  # 
  连接服务器的端口和IP 
  
tran.start_client() 
  
default_path = os.path.join(os.environ[ 
  ' 
  HOME 
  '],  
  ' 
  .ssh 
  ',  
  ' 
  id_rsa 
  ') 
  
 
  # 
  连接方式，使用密钥 
  
key = paramiko.RSAKey.from_private_key_file(default_path) 
  
 
  # 
  密钥默认路径 
  
tran.auth_publickey( 
  ' 
  wulaoer 
  ', key) 
  
 
  # 
  连接用户名和密钥 
  
  
  
 
  # 
   打开一个通道 
  
chan = tran.open_session() 
  
 
  # 
   获取一个终端 
  
chan.get_pty() 
  
 
  # 
   激活器 
  
chan.invoke_shell() 
  
  
  
 
  # 
  ######## 
  
# 
   利用sys.stdin,肆意妄为执行操作 
  
# 
   用户在终端输入内容，并将内容发送至远程服务器 
  
# 
   远程服务器执行命令，并将结果返回 
  
# 
   用户终端显示内容 
  
# 
  ######## 
 

用户监控日志：

 
  while True: 
  
     
  # 
   监视用户输入和服务器返回数据 
  
     
  # 
   sys.stdin 处理用户输入 
  
     
  # 
   chan 是之前创建的通道，用于接收服务器返回信息 
  
    readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1) 
  
     
  if chan  
  in readable: 
  
         
  try: 
  
            x = chan.recv(1024) 
  
             
  if len(x) == 0: 
  
                 
  print  
  ' 
  \r\n*** EOF\r\n 
  ', 
  
                 
  break 
  
            sys.stdout.write(x) 
  
            sys.stdout.flush() 
  
         
  except socket.timeout: 
  
             
  pass 
  
     
  if sys.stdin  
  in readable: 
  
        inp = sys.stdin.readline() 
  
        chan.sendall(inp) 
 

 
  # 
   获取原tty属性 
  
oldtty = termios.tcgetattr(sys.stdin) 
  
 
  try: 
  
     
  # 
   为tty设置新属性 
  
     
  # 
   默认当前tty设备属性： 
  
     
  # 
     输入一行回车，执行 
  
     
  # 
     CTRL+C 进程退出，遇到特殊字符，特殊处理。 
  
 
  
     
  # 
   这是为原始模式，不认识所有特殊符号 
  
     
  # 
   放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器 
  
    tty.setraw(sys.stdin.fileno()) 
  
    chan.settimeout(0.0) 
  
 
  
     
  while True: 
  
         
  # 
   监视 用户输入 和 远程服务器返回数据（socket） 
  
         
  # 
   阻塞，直到句柄可读 
  
        r, w, e = select.select([chan, sys.stdin], [], [], 1) 
  
         
  if chan  
  in r: 
  
             
  try: 
  
                x = chan.recv(1024) 
  
                 
  if len(x) == 0: 
  
                     
  print  
  ' 
  \r\n*** EOF\r\n 
  ', 
  
                     
  break 
  
                sys.stdout.write(x) 
  
                sys.stdout.flush() 
  
             
  except socket.timeout: 
  
                 
  pass 
  
         
  if sys.stdin  
  in r: 
  
            x = sys.stdin.read(1) 
  
             
  if len(x) == 0: 
  
                 
  break 
  
            chan.send(x) 
  
 
  
 
  finally: 
  
     
  # 
   重新设置终端属性 
  
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty) 
 

 
  def windows_shell(chan): 
  
     
  import threading 
  
 
  
    sys.stdout.write( 
  " 
  Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n 
  ") 
  
 
  
     
  def writeall(sock): 
  
         
  while True: 
  
            data = sock.recv(256) 
  
             
  if  
  not data: 
  
                sys.stdout.write( 
  ' 
  \r\n*** EOF ***\r\n\r\n 
  ') 
  
                sys.stdout.flush() 
  
                 
  break 
  
            sys.stdout.write(data) 
  
            sys.stdout.flush() 
  
 
  
    writer = threading.Thread(target=writeall, args=(chan,)) 
  
    writer.start() 
  
 
  
     
  try: 
  
         
  while True: 
  
            d = sys.stdin.read(1) 
  
             
  if  
  not d: 
  
                 
  break 
  
            chan.send(d) 
  
     
  except EOFError: 
  
         
  # 
   user hit ^Z or F6 
  
         
  pass 
 

 注：密码验证t.auth_password(username,pw)

 详见：paramiko源码demo

三、数据库操作

 Python操作 Mysql模块的安装

   linux： 
  
    yum install MySQL-python 
  
  
  
window： 
  
    http://files.cnblogs.com/files/wupeiqi/py-mysql-win.zip 
 

 SQL基本使用

1、数据库操作

   show databases;   
  # 
  查看数据库 
  
use [databasename];   
  # 
  切换数据或者进入数据库 
  
create database  [name];  
  # 
  新建数据库 
 

 2、数据表操作

   show tables;  
  # 
  查看数据库表 
  
  
  
create table students  
  # 
  新建数据库表 
  
    ( 
  
        id int   
  not null auto_increment primary key, 
  
        name char(8)  
  not null, 
  
        sex char(4)  
  not null, 
  
        age tinyint unsigned  
  not null, 
  
        tel char(13) null default  
  " 
  - 
  " 
  
    ); 
 

 
  
    CREATE TABLE `wb_blog` (  
   
    `id` smallint(8) unsigned NOT NULL,  
   
    `catid` smallint(5) unsigned NOT NULL DEFAULT  
   ' 
   0 
   ',  
   
    `title` varchar(80) NOT NULL DEFAULT  
   '',  
   
    `content` text NOT NULL,  
   
    PRIMARY KEY (`id`),  
   
    UNIQUE KEY `catename` (`catid`)  
   
) ;  
   
 

 3、数据库操作

   insert into students(name,sex,age,tel) values( 
  ' 
  wulaoer 
  ', 
  ' 
  man 
  ',18, 
  ' 
  151515151 
  ') 
  
  
  # 
  插入表数据 
  
delete  
  from students where id =2; 
  
  
  # 
  删除表数据 
  
update students set name =  
  ' 
  dn 
  ' where id =1; 
  
  
  # 
  修改表数据 
  
select *  
  from students 
  
 
  # 
  查看整个表 
 

 4、其他

   主键 
  
外键 
  
左右连接 
 

更多mysql操作萌点这里

 Python MySQL API

一、插入数据

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import MySQLdb 
  
 
  
conn = MySQLdb.connect(host= 
  ' 
  127.0.0.1 
  ',user= 
  ' 
  root 
  ',passwd= 
  ' 
  123456 
  ',db= 
  ' 
  mydb 
  ') 
  
  
  # 
  根据IP、数据用户名、密码、数据库名。连接数据库 
  
cur = conn.cursor() 
  
 
  
reCount = cur.execute( 
  ' 
  insert into UserInfo(Name,Address) values(%s,%s) 
  ',( 
  ' 
  wulaoer 
  ', 
  ' 
  usa 
  ')) 
  
  
  # 
  进入数据库，插入一条数据 
  
conn.commit() 
  
 
  
cur.close() 
  
conn.close() 
  
 
  
 
  print reCount 
 

 
   
   # 
   !/usr/bin/env  python 
   
# 
    --*--coding:utf-8 --*-- 
   
 
   import MySQLdb 
   
 
   
conn = MySQLdb.connect(host= 
   ' 
   127.0.0.1 
   ',user= 
   ' 
   root 
   ',passwd= 
   ' 
   1234 
   ',db= 
   ' 
   mydb 
   ') 
   
 
   # 
   根据IP、数据用户名、密码、数据库名。连接数据库 
   
cur = conn.cursor() 
   
 
   
li =[ 
   
     ( 
   ' 
   wulaoer 
   ', 
   ' 
   usa 
   '), 
   
     ( 
   ' 
   dn 
   ', 
   ' 
   usa 
   '), 
   
] 
   
 
   # 
   插入的表 
   
reCount = cur.executemany( 
   ' 
   insert into UserInfo(Name,Address) values(%s,%s) 
   ',li) 
   
 
   
conn.commit() 
   
cur.close() 
   
conn.close() 
   
 
   
 
   print reCount 
   
 

 注意：cur.lastowid

二、删除数据

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import MySQLdb 
  
 
  
conn = MySQLdb.connect(host= 
  ' 
  127.0.0.1 
  ',user= 
  ' 
  root 
  ',passwd= 
  ' 
  1234 
  ',db= 
  ' 
  mydb 
  ') 
  
 
  # 
  根据IP、数据用户名、密码、数据库名。连接数据库 
  
cur = conn.cursor() 
  
 
  
reCount = cur.execute( 
  ' 
  delete from UserInfo 
  ') 
  
 
  # 
  删除数据 
  
conn.commit() 
  
 
  
cur.close() 
  
conn.close() 
  
 
  
 
  print reCount 
 

 三、修改数据

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
 
  import MySQLdb 
  
 
  
conn = MySQLdb.connect(host= 
  ' 
  127.0.0.1 
  ',user= 
  ' 
  root 
  ',passwd= 
  ' 
  1234 
  ',db= 
  ' 
  mydb 
  ') 
  
 
  # 
  根据IP、数据用户名、密码、数据库名。连接数据库 
  
cur = conn.cursor() 
  
 
  
reCount = cur.execute( 
  ' 
  update UserInfo set Name = %s 
  ',( 
  ' 
  alin 
  ',)) 
  
 
  # 
  修改数据 
  
conn.commit() 
  
cur.close() 
  
conn.close() 
  
 
  
 
  print reCount 
 

 四、查看数据

 
  # 
  !/usr/bin/env  python 
  
# 
   --*--coding:utf-8 --*-- 
  
# 
   ############################## fetchone/fetchmany(num)  ############################## 
  
 
  
 
  import MySQLdb 
  
 
  
conn = MySQLdb.connect(host= 
  ' 
  127.0.0.1 
  ',user= 
  ' 
  root 
  ',passwd= 
  ' 
  1234 
  ',db= 
  ' 
  mydb 
  ') 
  
 
  # 
  根据IP、数据用户名、密码、数据库名。连接数据库 
  
cur = conn.cursor() 
  
 
  
reCount = cur.execute( 
  ' 
  select * from UserInfo 
  ') 
  
 
  # 
  查看表数据 
  
 
  print cur.fetchone() 
  
 
  print cur.fetchone() 
  
cur.scroll(-1,mode= 
  ' 
  relative 
  ') 
  
 
  print cur.fetchone() 
  
 
  print cur.fetchone() 
  
cur.scroll(0,mode= 
  ' 
  absolute 
  ') 
  
 
  print cur.fetchone() 
  
 
  print cur.fetchone() 
  
 
  
cur.close() 
  
conn.close() 
  
 
  
 
  print reCount 
  
 
  
 
  
 
  
 
  # 
   ############################## fetchall  ############################## 
  
 
  
 
  import MySQLdb 
  
 
  
conn = MySQLdb.connect(host= 
  ' 
  127.0.0.1 
  ',user= 
  ' 
  root 
  ',passwd= 
  ' 
  1234 
  ',db= 
  ' 
  mydb 
  ') 
  
 
  # 
  根据IP、数据用户名、密码、数据库名。连接数据库 
  
# 
  cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) 
  
cur = conn.cursor() 
  
 
  
reCount = cur.execute( 
  ' 
  select Name,Address from UserInfo 
  ') 
  
 
  
nRet = cur.fetchall() 
  
 
  
cur.close() 
  
conn.close() 
  
 
  
 
  print reCount 
  
 
  print nRet 
  
 
  for i  
  in nRet: 
  
     
  print i[0],i[1]