Exemple de code pour que Python utilise paramiko pour se connecter à un serveur distant et exécuter des commandes

L'éditeur suivant vous proposera un article sur la façon d'utiliser Python pour se connecter à un serveur distant afin d'exécuter des commandes à l'aide de paramiko. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un coup d'œil

Le module paramiko en python est une bibliothèque utilisée pour implémenter des connexions SSH aux serveurs distants. Lors de la connexion, il peut être utilisé pour exécuter des commandes ou télécharger des fichiers.

1. Obtenez un objet de connexion

Lors de l'établissement d'une connexion, vous pouvez utiliser le code suivant :

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

Dans la fonction connect, le paramètre est l'adresse IP ou le nom d'hôte d'un hôte. Après avoir exécuté cette méthode, si le serveur est connecté avec succès, un objet sshclient sera renvoyé.

La première étape consiste à créer un objet SSHClient, puis à configurer le client ssh pour autoriser les connexions aux machines qui ne sont pas dans le fichier know_host, puis à essayer de vous connecter au serveur. Lors de la connexion au serveur, vous. peut utiliser deux méthodes : une La méthode consiste à utiliser la clé secrète, c'est-à-dire le paramètre look_for_keys Ici, vous utilisez le mot de passe défini pour rechercher, ou vous pouvez utiliser directement la méthode du mot de passe, c'est-à-dire utiliser directement le paramètre password, pour enfin restituer un objet connecté.

2. Obtenez la commande set

Après avoir établi la connexion paramiko, vous devez obtenir la commande qui doit être exécutée, comme indiqué dans le code suivant :

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

Parmi les paramètres, l'un est args et l'autre est outpath args représente les paramètres de la commande, et outpath représente le chemin de l'exécutable. fichier, tel que /usr/bin /ls -l. Parmi eux, outpath est /usr/bin/ls et le paramètre est -l

. Cette méthode est principalement utilisée pour combiner des commandes et assembler des paramètres distincts dans le cadre de la commande.

3. Exécuter la commande

Après la connexion, vous pouvez directement exécuter la commande, puis il y a la fonction suivante :

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

Dans cette fonction, l'un des paramètres transmis est l'objet de connexion conn, et l'autre est la commande cmd qui doit être exécutée. Enfin, le résultat de l'exécution est obtenu, qui est stdout.read ( ), et enfin renvoyer le résultat

4. Télécharger des fichiers

Lorsque vous utilisez l'objet de connexion, vous pouvez également télécharger directement les fichiers associés, la fonction suivante :

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

Les principaux paramètres de cette fonction sont, l'un est la connexion de l'objet de connexion, l'autre est le nom du fichier téléchargé et l'autre est le nom du fichier après le téléchargement. Celui-ci doit être écrit avec le nom complet du fichier, y compris le chemin.

La méthode principale consiste à ouvrir un objet sftp, puis à utiliser la méthode put pour télécharger le fichier, enfin à fermer la connexion sftp et enfin à renvoyer le chemin complet du nom du fichier téléchargé

5 , exécutez la commande et obtenez le résultat

La dernière étape consiste à exécuter la commande et obtenez le résultat renvoyé, comme suit :

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]

Tout d'abord, connectez-vous au serveur et obtenez un objet de connexion. Si la connexion échoue, le nom d'hôte et Aucun sont renvoyés, indiquant que la connexion échoue. réussi, puis modifiez l'autorisation d'exécution du fichier pour que le fichier puisse être exécuté, puis la commande exécutée est obtenue. Enfin, exécutez la commande, obtenez le résultat et renvoyez le résultat au format json, afin que le résultat puisse être. obtenu dans un beau format json, et renvoie enfin les informations pertinentes avec le nom d'hôte

6. Code de test

Le code de test est le suivant suit :

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')

La première étape teste l'exécution des commandes, la deuxième étape teste le téléchargement de fichiers et la troisième étape Le département teste les autorisations pour modifier les fichiers téléchargés.

Le code complet est le suivant :

#!/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')

Utilisant principalement le module paramiko en python via ssh Connectez-vous au serveur Linux, puis exécutez les commandes appropriées et téléchargez les fichiers sur le serveur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!