J'écris un script pour automatiser certaines commandes de ligne de commande en Python. En ce moment je fais des appels donc:

cmd = "some unix command"
retcode = subprocess.call(cmd,shell=True)

Cependant, j'ai besoin d'exécuter certaines commandes sur une machine distante. Manuellement, je me connectais en utilisant ssh puis j'exécutais les commandes. Comment pourrais-je automatiser cela en Python? Je dois me connecter avec un mot de passe (connu) à la machine distante, donc je ne peux pas simplement utiliser cmd = ssh user@remotehost, je me demande s'il y a un module que je devrais utiliser?

Je vais vous référer à paramiko

voir cette question

ssh = paramiko.SSHClient()
ssh.connect(server, username=username, password=password)
ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(cmd_to_execute)

Ou vous pouvez simplement utiliser commands.getstatusoutput :

   commands.getstatusoutput("ssh machine 1 'your script'")

Je l'ai beaucoup utilisé et cela fonctionne très bien.

Dans Python 2.6+, utilisez subprocess.check_output.

Avez-vous jeté un œil à Fabric ? Il vous permet de faire toutes sortes de choses à distance via SSH en utilisant python.

J'ai trouvé que paramiko était un peu trop bas niveau et que Fabric n'était pas particulièrement bien adapté pour être utilisé comme bibliothèque, j'ai donc créé ma propre bibliothèque appelée spur qui utilise paramiko pour implémenter une interface légèrement plus agréable:

import spur

shell = spur.SshShell(hostname="localhost", username="bob", password="password1")
result = shell.run(["echo", "-n", "hello"])
print result.output # prints hello

Si vous devez exécuter à l'intérieur d'un shell:

shell.run(["sh", "-c", "echo -n hello"])

Rester simple. Aucune bibliothèque requise.

import subprocess

subprocess.Popen("ssh {user}@{host} {cmd}".format(user=user, host=host, cmd='ls -l'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()

Tous ont déjà indiqué (recommandé) l'utilisation de paramiko et je ne fais que partager un code python (on peut dire API) qui vous permettra d'exécuter plusieurs commandes en une seule fois.

pour exécuter des commandes sur différents nœuds, utilisez: Commands().run_cmd(host_ip, list_of_commands)

Vous verrez un TODO, que j'ai gardé pour arrêter l'exécution si l'une des commandes ne s'exécute pas, je ne sais pas comment le faire. merci de partager vos connaissances

#!/usr/bin/python

import os
import sys
import select
import paramiko
import time


class Commands:
    def __init__(self, retry_time=0):
        self.retry_time = retry_time
        pass

    def run_cmd(self, host_ip, cmd_list):
        i = 0
        while True:
        # print("Trying to connect to %s (%i/%i)" % (self.host, i, self.retry_time))
        try:
            ssh = paramiko.SSHClient()
            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            ssh.connect(host_ip)
            break
        except paramiko.AuthenticationException:
            print("Authentication failed when connecting to %s" % host_ip)
            sys.exit(1)
        except:
            print("Could not SSH to %s, waiting for it to start" % host_ip)
            i += 1
            time.sleep(2)

        # If we could not connect within time limit
        if i >= self.retry_time:
            print("Could not connect to %s. Giving up" % host_ip)
            sys.exit(1)
        # After connection is successful
        # Send the command
        for command in cmd_list:
            # print command
            print "> " + command
            # execute commands
            stdin, stdout, stderr = ssh.exec_command(command)
            # TODO() : if an error is thrown, stop further rules and revert back changes
            # Wait for the command to terminate
            while not stdout.channel.exit_status_ready():
                # Only print data if there is data to read in the channel
                if stdout.channel.recv_ready():
                    rl, wl, xl = select.select([ stdout.channel ], [ ], [ ], 0.0)
                    if len(rl) > 0:
                        tmp = stdout.channel.recv(1024)
                        output = tmp.decode()
                        print output

        # Close SSH connection
        ssh.close()
        return

def main(args=None):
    if args is None:
        print "arguments expected"
    else:
        # args = {'<ip_address>', <list_of_commands>}
        mytest = Commands()
        mytest.run_cmd(host_ip=args[0], cmd_list=args[1])
    return


if __name__ == "__main__":
    main(sys.argv[1:])

Je vous remercie!

J'ai utilisé un tas de paramiko (sympa) et pxssh (également sympa). Je recommanderais non plus. Ils fonctionnent un peu différemment mais ont un chevauchement d'utilisation relativement important.

paramiko a finalement fonctionné pour moi après avoir ajouté une ligne supplémentaire, qui est vraiment importante (ligne 3):

import paramiko

p = paramiko.SSHClient()
p.set_missing_host_key_policy(paramiko.AutoAddPolicy())   # This script doesn't work for me unless this line is added!
p.connect("server", port=22, username="username", password="password")
stdin, stdout, stderr = p.exec_command("your command")
opt = stdout.readlines()
opt = "".join(opt)
print(opt)

Assurez-vous que le package paramiko est installé. Source originale de la solution: Source

#Reading the Host,username,password,port from excel file
import paramiko 
import xlrd

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

loc = ('/Users/harshgow/Documents/PYTHON_WORK/labcred.xlsx')
wo = xlrd.open_workbook(loc)
sheet = wo.sheet_by_index(0)
Host = sheet.cell_value(0,1)
Port = int(sheet.cell_value(3,1))
User = sheet.cell_value(1,1)
Pass = sheet.cell_value(2,1)

def details(Host,Port,User,Pass):
    ssh.connect(Host, Port, User, Pass)
    print('connected to ip ',Host)
    stdin, stdout, stderr = ssh.exec_command("")
    stdin.write('xcommand SystemUnit Boot Action: Restart\n')
    print('success')

details(Host,Port,User,Pass)

Fonctionne parfaitement...

import paramiko
import time

ssh = paramiko.SSHClient()
#ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('10.106.104.24', port=22, username='admin', password='')

time.sleep(5)
print('connected')
stdin, stdout, stderr = ssh.exec_command(" ")

def execute():
       stdin.write('xcommand SystemUnit Boot Action: Restart\n')
       print('success')

execute()

La réponse acceptée n'a pas fonctionné pour moi, voici ce que j'ai utilisé à la place:

import paramiko
import os

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ssh.load_system_host_keys()
ssh.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
ssh.connect("d.d.d.d", username="user", password="pass", port=22222)

ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command("ls -alrt")
exit_code = ssh_stdout.channel.recv_exit_status() # handles async exit error 

for line in ssh_stdout:
    print(line.strip())

total 44
-rw-r--r--.  1 root root  129 Dec 28  2013 .tcshrc
-rw-r--r--.  1 root root  100 Dec 28  2013 .cshrc
-rw-r--r--.  1 root root  176 Dec 28  2013 .bashrc
...

Vous pouvez également utiliser sshpass :

import subprocess
cmd = """ sshpass -p "myPas$" ssh [email protected] -p 22222 'my command; exit' """
print( subprocess.getoutput(cmd) )

Références:
1. https://github.com/onyxfish/relay/issues/11
2. https://stackoverflow.com/a/61016663/797495

Jetez un œil à spurplus, un wrapper que nous avons développé autour spurqui fournit des annotations de type et quelques gadgets mineurs (reconnexion SFTP, md5, etc. ): https://pypi.org/project/spurplus/

Demander à l'utilisateur d'entrer la commande en fonction de l'appareil
auquel il se connecte. Le code ci-dessous est validé par PEP8online.com.

import paramiko
import xlrd
import time

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
loc = ('/Users/harshgow/Documents/PYTHON_WORK/labcred.xlsx')
wo = xlrd.open_workbook(loc)
sheet = wo.sheet_by_index(0)
Host = sheet.cell_value(0, 1)
Port = int(sheet.cell_value(3, 1))
User = sheet.cell_value(1, 1)
Pass = sheet.cell_value(2, 1)

def details(Host, Port, User, Pass):
    time.sleep(2)
    ssh.connect(Host, Port, User, Pass)
    print('connected to ip ', Host)
    stdin, stdout, stderr = ssh.exec_command("")
    x = input('Enter the command:')
    stdin.write(x)
    stdin.write('\n')
    print('success')

details(Host, Port, User, Pass)

Exemple ci-dessous, dans le cas où vous voulez des entrées utilisateur pour le nom d'hôte, le nom d'utilisateur, le mot de passe et le numéro de port.

  import paramiko

  ssh = paramiko.SSHClient()

  ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())



  def details():

  Host = input("Enter the Hostname: ")

  Port = input("Enter the Port: ")

  User = input("Enter the Username: ")

  Pass = input("Enter the Password: ")

  ssh.connect(Host, Port, User, Pass, timeout=2)

  print('connected')

  stdin, stdout, stderr = ssh.exec_command("")

  stdin.write('xcommand SystemUnit Boot Action: Restart\n')

  print('success')

  details()