Sample code for python to use paramiko to connect to a remote server and execute commands

The following editor will bring you an article on how python uses paramiko to connect to a remote server to execute commands. The editor thinks it is quite good, so I will share it with you now and give it as a reference for everyone. Let’s follow the editor and take a look.

The paramiko module in python is a library used to implement SSH connections to remote servers. When connecting, it can be used to execute commands or upload files. .

1. Get a connection object

When connecting, you can use the following code:

def connect(host):
  'this is use the paramiko connect the host,return conn'
  ssh = paramiko.SSHClient()
  ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  try:
#    ssh.connect(host,username='root',allow_agent=True,look_for_keys=True)
    ssh.connect(host,username='root',password='root',allow_agent=True)
    return ssh
  except:
    return None

In the connect function, the parameter is the IP address or host name of a host. After executing this method, if the server is successfully connected, an sshclient object will be returned.

The first step is to create an SSHClient object, then set the ssh client to allow connections to machines that are not in the know_host file, and then try to connect to the server. When connecting to the server, you can use two methods: one The method is to use the secret key, that is, the parameter look_for_keys. Here, you use the set password to search, or you can directly use the password method, that is, directly use the parameter password, so as to finally return a connected object.

2. Get the set command

After making the paramiko connection, you must get the command that needs to be executed, as shown in the following code:

def command(args,outpath):
  'this is get the command the args to return the command'
  cmd = '%s %s' % (outpath,args)
  return cmd

Among the parameters, one is args and one is outpath. args represents the parameters of the command, and outpath represents the path of the executable file, such as /usr/bin/ls -l. Among them, outpath is /usr/bin/ls, and the parameter is -l

. This method is mainly used to combine commands, and assemble separate parameters as part of the command.

3. Execute the command

After the connection, you can directly execute the command, then there is the following function:

def exec_commands(conn,cmd):
  'this is use the conn to excute the cmd and return the results of excute the command'
  stdin,stdout,stderr = conn.exec_command(cmd)
  results=stdout.read()
  return results

In this function, one of the parameters passed in is the connection object conn, and the other is the command cmd that needs to be executed. Finally, the execution result is obtained, which is stdout.read(), Finally return the result

4. Upload files

When using the connection object, you can also directly upload related files, as follows Function:

def copy_moddule(conn,inpath,outpath):
  'this is copy the module to the remote server'
  ftp = conn.open_sftp()
  ftp.put(inpath,outpath)
  ftp.close()
  return outpath

The main parameters of this function are, one is the connection object conn, the other is the name of the uploaded file, and the name of the file after uploading, which must be written here Full file name including path.

The main method is to open an sftp object, then use the put method to upload the file, finally close the sftp connection, and finally return the full path of the uploaded file name

5 , Execute the command to get the result

The last step is to execute the command and get the returned result, the following code:

def excutor(host,outpath,args):
  conn = connect(host)
  if not conn:
    return [host,None]
  exec_commands(conn,'chmod +x %s' % outpath)
  cmd =command(args,outpath)
  result = exec_commands(conn,cmd)
  print '%r' % result
  result = json.loads(result)
  return [host,result]

First, proceed Connect to the server and get a connection object. If the connection is unsuccessful, the host name and None are returned, indicating that the connection is not successful. If the connection is successful, the execution permission of the file is modified so that the file can be executed, and the execution command is obtained. Finally, execution is performed command, get the result, and return the result in json format, so that the result can be in a beautiful json format, and finally return relevant information together with the host name

6. Test code

The test code is as follows:

if __name__ == '__main__':
  print json.dumps(excutor('192.168.1.165','ls',' -l'),indent=4,sort_keys=True)
  print copy_module(connect('192.168.1.165'),'kel.txt','/root/kel.1.txt')
  exec_commands(connect('192.168.1.165'),'chmod +x %s' % '/root/kel.1.txt')

The first step tests command execution, the second step tests uploading files, and the third step tests uploading modifications. File permissions.

The complete code is as follows:

#!/usr/bin/env python
import json
import paramiko

def connect(host):
  'this is use the paramiko connect the host,return conn'
  ssh = paramiko.SSHClient()
  ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  try:
#    ssh.connect(host,username='root',allow_agent=True,look_for_keys=True)
    ssh.connect(host,username='root',password='root',allow_agent=True)
    return ssh
  except:
    return None

def command(args,outpath):
  'this is get the command the args to return the command'
  cmd = '%s %s' % (outpath,args)
  return cmd

def exec_commands(conn,cmd):
  'this is use the conn to excute the cmd and return the results of excute the command'
  stdin,stdout,stderr = conn.exec_command(cmd)
  results=stdout.read()
  return results

def excutor(host,outpath,args):
  conn = connect(host)
  if not conn:
    return [host,None]
  #exec_commands(conn,'chmod +x %s' % outpath)
  cmd =command(args,outpath)
  result = exec_commands(conn,cmd)
  result = json.dumps(result)
  return [host,result]

def copy_module(conn,inpath,outpath):
    'this is copy the module to the remote server'
    ftp = conn.open_sftp()
    ftp.put(inpath,outpath)
    ftp.close()
    return outpath


if __name__ == '__main__':
    print json.dumps(excutor('192.168.1.165','ls',' -l'),indent=4,sort_keys=True)
    print copy_module(connect('192.168.1.165'),'kel.txt','/root/kel.1.txt')
    exec_commands(connect('192.168.1.165'),'chmod +x %s' % '/root/kel.1.txt')

Mainly uses the paramiko module in python to connect to the Linux server through ssh. Then execute the relevant commands and upload the file to the server.

The above is the detailed content of Sample code for python to use paramiko to connect to a remote server and execute commands. For more information, please follow other related articles on the PHP Chinese website!