在 Twisted 中通过 ssh 运行远程命令的最佳方式？

Question

我有一个扭曲的应用程序，现在需要监视在多个盒子上运行的进程。我手动执行的方式是“ssh 和 ps”，现在我希望我的扭曲应用程序执行此操作。我有两个选择。

使用 paramiko 或利用 twisted.conch

我真的很想使用 twisted.conch 但我的研究让我相信它的主要目的创建 SSHServer 和 SSHClient。然而，我的要求是一个简单的 remoteExecute(some_cmd)

我能够弄清楚如何使用 paramiko 来做到这一点，但我不想坚持paramiko在我的扭曲应用程序中，在查看如何使用 twisted.conch 执行此操作之前，

使用 twisted 来了解如何使用 ssh 运行 remote_cmds 的代码片段将非常有用赞赏。谢谢。

Answer 1

后续 - 令人高兴的是，我在下面提到的问题现已解决。更简单的 API 将包含在 Twisted 的下一版本中。最初的答案仍然是使用 Conch 的有效方法，并且可能会揭示一些有关正在发生的事情的有趣细节，但从 Twisted 13.1 及更高版本开始，如果您只想运行命令并处理它的 I/O，这个更简单的界面将起作用。

---

不幸的是，使用 Conch 客户端 API 在 SSH 上执行命令需要大量代码。 Conch 可以让您处理许多不同的层，即使您只想要合理的、无聊的默认行为。然而，这当然是可能的。以下是我一直想完成并添加到 Twisted 中以简化此情况的一些代码：

import sys, os

from zope.interface import implements

from twisted.python.failure import Failure
from twisted.python.log import err
from twisted.internet.error import ConnectionDone
from twisted.internet.defer import Deferred, succeed, setDebugging
from twisted.internet.interfaces import IStreamClientEndpoint
from twisted.internet.protocol import Factory, Protocol

from twisted.conch.ssh.common import NS
from twisted.conch.ssh.channel import SSHChannel
from twisted.conch.ssh.transport import SSHClientTransport
from twisted.conch.ssh.connection import SSHConnection
from twisted.conch.client.default import SSHUserAuthClient
from twisted.conch.client.options import ConchOptions

# setDebugging(True)


class _CommandTransport(SSHClientTransport):
    _secured = False

    def verifyHostKey(self, hostKey, fingerprint):
        return succeed(True)


    def connectionSecure(self):
        self._secured = True
        command = _CommandConnection(
            self.factory.command,
            self.factory.commandProtocolFactory,
            self.factory.commandConnected)
        userauth = SSHUserAuthClient(
            os.environ['USER'], ConchOptions(), command)
        self.requestService(userauth)


    def connectionLost(self, reason):
        if not self._secured:
            self.factory.commandConnected.errback(reason)



class _CommandConnection(SSHConnection):
    def __init__(self, command, protocolFactory, commandConnected):
        SSHConnection.__init__(self)
        self._command = command
        self._protocolFactory = protocolFactory
        self._commandConnected = commandConnected


    def serviceStarted(self):
        channel = _CommandChannel(
            self._command, self._protocolFactory, self._commandConnected)
        self.openChannel(channel)



class _CommandChannel(SSHChannel):
    name = 'session'

    def __init__(self, command, protocolFactory, commandConnected):
        SSHChannel.__init__(self)
        self._command = command
        self._protocolFactory = protocolFactory
        self._commandConnected = commandConnected


    def openFailed(self, reason):
        self._commandConnected.errback(reason)


    def channelOpen(self, ignored):
        self.conn.sendRequest(self, 'exec', NS(self._command))
        self._protocol = self._protocolFactory.buildProtocol(None)
        self._protocol.makeConnection(self)


    def dataReceived(self, bytes):
        self._protocol.dataReceived(bytes)


    def closed(self):
        self._protocol.connectionLost(
            Failure(ConnectionDone("ssh channel closed")))



class SSHCommandClientEndpoint(object):
    implements(IStreamClientEndpoint)

    def __init__(self, command, sshServer):
        self._command = command
        self._sshServer = sshServer


    def connect(self, protocolFactory):
        factory = Factory()
        factory.protocol = _CommandTransport
        factory.command = self._command
        factory.commandProtocolFactory = protocolFactory
        factory.commandConnected = Deferred()

        d = self._sshServer.connect(factory)
        d.addErrback(factory.commandConnected.errback)

        return factory.commandConnected



class StdoutEcho(Protocol):
    def dataReceived(self, bytes):
        sys.stdout.write(bytes)
        sys.stdout.flush()


    def connectionLost(self, reason):
        self.factory.finished.callback(None)



def copyToStdout(endpoint):
    echoFactory = Factory()
    echoFactory.protocol = StdoutEcho
    echoFactory.finished = Deferred()
    d = endpoint.connect(echoFactory)
    d.addErrback(echoFactory.finished.errback)
    return echoFactory.finished



def main():
    from twisted.python.log import startLogging
    from twisted.internet import reactor
    from twisted.internet.endpoints import TCP4ClientEndpoint

    # startLogging(sys.stdout)

    sshServer = TCP4ClientEndpoint(reactor, "localhost", 22)
    commandEndpoint = SSHCommandClientEndpoint("/bin/ls", sshServer)

    d = copyToStdout(commandEndpoint)
    d.addErrback(err, "ssh command / copy to stdout failed")
    d.addCallback(lambda ignored: reactor.stop())
    reactor.run()



if __name__ == '__main__':
    main()

需要注意的一些事项：

• 它使用 Twisted 10.1 中引入的新端点 API。可以直接在 Reactor.connectTCP 上执行此操作，但我将其作为端点来执行，以使其更有用；端点可以轻松交换，而无需实际请求连接的代码知道。
• 它根本不进行主机密钥验证！ _CommandTransport.verifyHostKey 是您实现该功能的地方。查看 twisted/conch/client/default.py 以获得有关您可能想做的事情的一些提示。
• 它需要 $USER 作为远程用户名，您可能希望将其作为参数。
• 它可能只适用于密钥身份验证。如果您想启用密码身份验证，您可能需要子类化 SSHUserAuthClient 并重写 getPassword 来执行某些操作。
• SSH 和 Conch 的几乎所有层都可以在这里看到：
  • _CommandTransport 位于底部，是一个实现 SSH 传输协议的普通旧协议。它创建了一个...
  • _CommandConnection 实现协议的 SSH 连接协商部分。完成后，...
  • _CommandChannel 用于与新打开的 SSH 通道进行通信。 _CommandChannel 执行实际的 exec 来启动您的命令。一旦通道打开，它就会创建一个......的实例
  • StdoutEcho，或您提供的任何其他协议。该协议将从您执行的命令中获取输出，并可以写入命令的标准输入。

请参阅 http://twistedmatrix.com/trac/ticket/4698 了解 Twisted 在支持方面的进展这用更少的代码。