¿Cómo copiar un archivo a un servidor remoto en Python usando SCP o SSH?

Question

Tengo un archivo de texto en mi equipo local que se genera mediante un script diario de Python ejecutado en cron.

Me gustaría agregar un poco de código para que el archivo se envíe de forma segura a mi servidor a través de SSH.

Answer 1

Si desea un enfoque simple, esto debería funcionar.

Querrá ".close()" el ​​archivo primero para que sepa que se ha eliminado del disco de Python.

import os 
os.system("scp FILE USER@SERVER:PATH") 
#e.g. os.system("scp foo.bar joe@srvr.net:/path/to/foo.bar") 

necesita generar (en la máquina de origen) e instalar (en la máquina de destino) una clave SSH de antemano para que el SCP automáticamente se autentica con su clave pública SSH (en otras palabras, por lo que su guión doesn no pida una contraseña).

ssh-keygen example

Answer 2

tipo de hacky, pero los siguientes deben trabajar :)

import os 
filePath = "/foo/bar/baz.py" 
serverPath = "/blah/boo/boom.py" 
os.system("scp "+filePath+" user@myserver.com:"+serverPath) 

Answer 3

lo que probablemente utiliza el subprocess module. Algo como esto:

import subprocess 
p = subprocess.Popen(["scp", myfile, destination]) 
sts = os.waitpid(p.pid, 0) 

Dónde destination es, probablemente, de la forma user@remotehost:remotepath. Gracias a @Charles Duffy por señalar la debilidad en mi respuesta original, que utilizaba un argumento de cadena única para especificar la operación scp shell=True - que no manejaría el espacio en blanco en las rutas.

La documentación del módulo tiene examples of error checking that you may want to perform in conjunction with this operation.

Asegúrese de que haya configurado las credenciales adecuadas para que pueda realizar una unattended, passwordless scp between the machines. Hay un stackoverflow question for this already.

Answer 4

Hay un par de diferentes maneras de abordar el problema:

1. programas de línea de comandos Wrap
2. utilizar una biblioteca de Python que proporciona capacidades de SSH (por ejemplo - Paramiko o Twisted Conch)

Cada enfoque tiene sus propias peculiaridades. Tendrá que configurar las claves SSH para habilitar inicios de sesión sin contraseña si está envolviendo comandos del sistema como "ssh", "scp" o "rsync". Puede insertar una contraseña en un script utilizando Paramiko o alguna otra biblioteca, pero puede encontrar frustrante la falta de documentación, especialmente si no está familiarizado con los conceptos básicos de la conexión SSH (por ejemplo, intercambios de claves, agentes, etc.). Probablemente no hace falta decir que las claves SSH son casi siempre una mejor idea que las contraseñas para este tipo de cosas.

NOTA: es difícil de superar rsync si planea transferir archivos a través de SSH, especialmente si la alternativa es simple viejo scp.

He utilizado Paramiko con miras a reemplazar las llamadas al sistema, pero me encontré de regreso a los comandos envueltos debido a su facilidad de uso y familiaridad inmediata. Usted puede ser diferente. Le di la vuelta a Conch hace algún tiempo pero no me atraía.

Si opta por la ruta de la llamada al sistema, Python ofrece una serie de opciones como os.system o los comandos/subprocesos de los módulos. Iré con el módulo de subproceso si uso la versión 2.4+.

Answer 5

Para hacer esto en Python (es decir, no a través de envolver SCP subprocess.Popen o similar) con la biblioteca Paramiko, que haría algo como esto:

import os 
import paramiko 

ssh = paramiko.SSHClient() 
ssh.load_host_keys(os.path.expanduser(os.path.join("~", ".ssh", "known_hosts"))) 
ssh.connect(server, username=username, password=password) 
sftp = ssh.open_sftp() 
sftp.put(localpath, remotepath) 
sftp.close() 
ssh.close() 

(Probablemente querría hacer frente a los ejércitos desconocidos , errores, creación de directorios necesarios, etc.).

Answer 6

fabric podrían utilizarse para cargar archivos vis SSH:

#!/usr/bin/env python 
from fabric.api import execute, put 
from fabric.network import disconnect_all 

if __name__=="__main__": 
    import sys 
    # specify hostname to connect to and the remote/local paths 
    srcdir, remote_dirname, hostname = sys.argv[1:] 
    try: 
     s = execute(put, srcdir, remote_dirname, host=hostname) 
     print(repr(s)) 
    finally: 
     disconnect_all() 

Answer 7

Calling scp comando a través de subproceso no permite recibir el informe de situación dentro del guión. pexpect podrían utilizarse para extraer esa información:

import pipes 
import re 
import pexpect # $ pip install pexpect 

def progress(locals): 
    # extract percents 
    print(int(re.search(br'(\d+)%$', locals['child'].after).group(1))) 

command = "scp %s %s" % tuple(map(pipes.quote, [srcfile, destination])) 
pexpect.run(command, events={r'\d+%': progress}) 

Ver python copy file in local network (linux -> linux)

Answer 8

alcanzado el mismo problema, pero en lugar de la "piratería" o emulando línea de comandos:

encontrado esta respuesta here.

from paramiko import SSHClient 
from scp import SCPClient 

ssh = SSHClient() 
ssh.load_system_host_keys() 
ssh.connect('example.com') 

with SCPClient(ssh.get_transport()) as scp: 
    scp.put('test.txt', 'test2.txt') 
    scp.get('test2.txt') 

Answer 9

from paramiko import SSHClient 
from scp import SCPClient 
import os 

ssh = SSHClient() 
ssh.load_host_keys(os.path.expanduser(os.path.join("~", ".ssh", "known_hosts"))) 
ssh.connect(server, username='username', password='password') 
with SCPClient(ssh.get_transport()) as scp: 
     scp.put('test.txt', 'test2.txt') 

Answer 10

un enfoque muy simple es la siguiente:

import os 
sshpass -p "password" scp user@host:/path/to/file ./ 

se requiere ninguna biblioteca de Python (sólo OS) y funciona

Answer 11

Solía ​​sshfs para montar el directorio remoto a través ssh, y shutil para copiar los archivos:

$ mkdir ~/sshmount 
$ sshfs user@remotehost:/path/to/remote/dst ~/sshmount 

Luego, en Python:

import shutil 
shutil.copy('a.txt', '~/sshmount') 

Este método tiene la ventaja de que puede transmitir datos a través de si está generando datos en lugar de almacenamiento en caché local y el envío de un solo archivo grande.