Python-Serverprogrammierung: Verwendung von Paramiko zur Implementierung des SSH-Remotebetriebs

Mit der Entwicklung von Cloud Computing und dem Internet der Dinge wird die Fernbedienung von Servern immer wichtiger. In Python können wir das Paramiko-Modul verwenden, um SSH-Remote-Operationen einfach zu implementieren. In diesem Artikel stellen wir die grundlegende Verwendung von Paramiko und die Verwendung von Paramiko in Python zur Fernverwaltung von Servern vor.

Was ist Paramiko?

Paramiko ist ein Python-Modul für SSHv1 und SSHv2, mit dem SSH-Clients und SSH-Server verbunden und gesteuert werden können. Mit dem Paramiko-Modul können Sie ganz einfach Python-Skripte schreiben, um sich aus der Ferne anzumelden und den Server zu bedienen.

Grundlegende Verwendung von Paramiko

Die grundlegende Verwendung des Paramiko-Moduls ist sehr einfach. Wir können die SSHClient-Klasse von Paramiko verwenden, um ein SSH-Client-Objekt zu erstellen und eine Verbindung zum SSH-Server herzustellen. Hier ist ein einfaches Beispiel:

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('hostname', username='username', password='password')

In diesem Beispiel erstellen wir zunächst ein SSHClient-Objekt und verwenden die Methode set_missing_host_key_policy, um das automatische Hinzufügen fehlender SSH-Schlüssel zu ermöglichen. Anschließend stellen wir über die Connect-Methode eine Verbindung zum SSH-Server her und übergeben dabei den Hostnamen, den Benutzernamen und das Passwort als Parameter.

Jetzt haben wir uns erfolgreich mit dem SSH-Server verbunden. Als nächstes können wir das SSHClient-Objekt verwenden, um Remote-Befehle auszuführen, beispielsweise um die Betriebssysteminformationen des Servers abzurufen:

stdin, stdout, stderr = ssh.exec_command('uname -a')
print(stdout.read())

In diesem Beispiel verwenden wir die Methode exec_command, um den Befehl uname -a auszuführen und die Ausgabe abzurufen. Wir haben auch stdout.read() verwendet, um die Ausgabe zu lesen und auszudrucken.

Zusätzlich zum Ausführen von Remote-Befehlen können wir SSHClient-Objekte auch zum Hoch- und Herunterladen von Dateien verwenden. Das Folgende ist ein Beispiel für das Hochladen von Dateien:

sftp = ssh.open_sftp()
local_file = '/path/to/local/file.txt'
remote_file = '/path/to/remote/file.txt'
sftp.put(local_file, remote_file)
sftp.close()

In diesem Beispiel verwenden wir zunächst die open_sftp-Methode, um eine SFTP-Sitzung zu öffnen, und verwenden die put-Methode, um lokale Dateien auf den Remote-Server hochzuladen. Wir haben auch die Methode sftp.close() verwendet, um die SFTP-Sitzung zu schließen.

Verwenden Sie Paramiko, um den SSH-Fernbetrieb zu implementieren

Da wir nun die grundlegende Verwendung von Paramiko verstanden haben, werden wir als Nächstes Paramiko verwenden, um den Server aus der Ferne zu bedienen. Wir werden die folgende Funktionalität implementieren:

• Verbindung zu einem SSH-Server herstellen und einige grundlegende Befehle ausführen
• Ordner erstellen und löschen
• Dateien hoch- und herunterladen

Zuerst müssen wir das Paramiko-Modul installieren:

pip install paramiko

Als nächstes Lassen Sie uns Python-Skripte schreiben. Zuerst importieren wir die notwendigen Module:

import os
import paramiko

Dann definieren wir einige Konstanten, darunter den Hostnamen, den Benutzernamen und das Passwort des SSH-Servers:

HOST = 'hostname'
USER = 'username'
PASSWORD = 'password'

Als nächstes können wir die Klasse paramiko.SSHClient verwenden, um eine Verbindung zum SSH-Server herzustellen:

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(HOST, username=USER, password=PASSWORD)

In diesem Beispiel haben wir die Methode set_missing_host_key_policy() verwendet, um fehlende SSH-Schlüssel automatisch hinzuzufügen.

Als nächstes definieren wir einige Funktionen, um verschiedene Aufgaben auszuführen. Erstens ist die Funktion, die den Befehl ausführt:

def run_command(command):
    stdin, stdout, stderr = ssh.exec_command(command)
    output = stdout.read().decode('utf-8')
    return output

Diese Funktion empfängt einen Befehlsparameter, verwendet die exec_command-Methode des SSHClient-Objekts, um diesen Befehl auszuführen, und gibt die Ausgabe als Zeichenfolge zurück.

Als nächstes definieren wir eine Funktion zum Erstellen eines Verzeichnisses:

def create_directory(path):
    sftp = ssh.open_sftp()
    try:
        sftp.mkdir(path)
    except IOError:
        pass
    sftp.close()

Diese Funktion empfängt einen Pfadparameter und erstellt ein Verzeichnis mithilfe einer SFTP-Sitzung.

Wir definieren auch Funktionen zum Hoch- und Herunterladen von Dateien:

def upload_file(local_path, remote_path):
    sftp = ssh.open_sftp()
    sftp.put(local_path, remote_path)
    sftp.close()


def download_file(remote_path, local_path):
    sftp = ssh.open_sftp()
    sftp.get(remote_path, local_path)
    sftp.close()

Diese Funktionen empfangen einen lokalen Pfad und einen Remote-Pfad (zum Hochladen) bzw. einen Remote-Pfad und einen lokalen Pfad (zum Herunterladen) und verwenden zum Hochladen eine SFTP-Sitzung Laden Sie die entsprechende Datei herunter.

Abschließend definieren wir eine Hauptfunktion, um alle Aufgaben auszuführen:

def main():
    # Run a command
    output = run_command('ls -la')
    print(output)

    # Create a directory
    create_directory('/home/username/new_folder')

    # Upload a file
    upload_file('/path/to/local/file.txt', '/home/username/new_folder/file.txt')

    # Download a file
    download_file('/home/username/new_folder/file.txt', '/path/to/local/file.txt')

    # Close the SSH connection
    ssh.close()

Diese Hauptfunktion führte die folgenden Aufgaben aus:

• Führte den Befehl ls -la aus und druckte die Ausgabe
• Erstellte ein neues Verzeichnis
• Hochgeladen a Datei
• Die gleiche Datei heruntergeladen
• Die SSH-Verbindung geschlossen

Jetzt können wir dieses Skript ausführen und die Ausgabe sehen:

python ssh.py

Das Ergebnis sollte etwa so aussehen:

total 20
drwxr-xr-x 1 username username 4096 Aug 15 02:24 .
drwxr-xr-x 1 username username 4096 Aug 15 02:20 ..
-rw------- 1 username username 1675 Aug 15 02:21 .bash_history
-rw-r--r-- 1 username username  220 Aug 15 02:20 .bash_logout
-rw-r--r-- 1 username username 3771 Aug 15 02:20 .bashrc
drwx------ 1 username username 4096 Aug 15 02:20 .cache
drwxr-xr-x 1 username username 4096 Aug 15 02:20 .config
drwx------ 1 username username 4096 Aug 15 02:20 .gnupg
-rw-r--r-- 1 username username  807 Aug 15 02:20 .profile
-rw-r--r-- 1 username username    0 Aug 15 02:21 test.txt

Zusammenfassung

Dies kann leicht erreicht werden mit das Paramiko-Modul SSH-Fernbedienung. In diesem Artikel haben wir die grundlegende Verwendung von Paramiko vorgestellt und gezeigt, wie man Paramiko in Python zur Fernverwaltung von Servern verwendet. Ob im Bereich Cloud Computing oder dem Internet der Dinge, Paramiko ist ein sehr nützliches Tool, das uns bei der Automatisierung der Serververwaltung helfen kann.

Das obige ist der detaillierte Inhalt vonPython-Serverprogrammierung: Verwendung von Paramiko zur Implementierung des SSH-Remotebetriebs. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!