golang标准库SSH操作示例详解

在golang中，有几个常用的ssh库，如golang.org/x/crypto/ssh和github.com/go-ssh/ssh。
本次将重点介绍golang.org/x/crypto/ssh，因为它是由go官方维护的.
ssh库功能分类:
    ssh客户端: 允许用户通过ssh协议连接到远程服务器。
    ssh服务器: 允许远程用户通过ssh协议连接到本地服务器。
    命令执行: 在远程服务器上执行命令。
    文件传输: 在本地和远程服务器之间传输文件。
    交会时会话: 类比xshell,当代码执行后,如同在操作真实的xshell一样

go get golang.org/x/crypto/ssh

1、client 对象（ssh 客户端）在整个程序中只创建一次
2、可以通过 client.newsession() 多次创建多个 session 对象.每个 session 是一个独立的会话，每次执行命令时都会创建一个新的会话
3、每次 session.run() 或 session.start() 执行命令时，都会用新的会话来执行不同的命令
	这些会话共享底层的 ssh 连接，但是它们独立执行命令
4、当某个会话的命令执行完毕，必须调用session.close() 释放相关资源。
5、切记不能在同一个 session 上并行执行多个命令。如果需要并行执行多个命令，应该创建多个 session

package main
import (
	"fmt"
	"golang.org/x/crypto/ssh"
	"log"
)
func main() {
	// ssh 配置
	config := &ssh.clientconfig{
		user: "root", // 替换为远程服务器的用户名
		auth: []ssh.authmethod{
			ssh.password("1"), // 替换为远程服务器密码
		},
		hostkeycallback: ssh.insecureignorehostkey(), // 忽略主机密钥验证
	}
	// 连接远程服务器
	client, err := ssh.dial("tcp", "192.168.56.160:22", config) // 替换为远程服务器的ip地址
	if err != nil {
		log.fatalf("failed to dial: %v", err)
	}
	defer client.close()
	// 创建第一个会话
	session1, err := client.newsession()
	if err != nil {
		log.fatalf("failed to create session 1: %v", err)
	}
	defer session1.close()
	// 执行第一个命令
	fmt.println("executing command on session 1-1")
	err = session1.run("echo hello from session 1-1")
	if err != nil {
		log.fatalf("failed to run command on session 1-1: %v", err)
	}
	// 演示在第一个会话中执行第二个命令看是否能成功
    fmt.println("executing command on session 1-2")
	err = session1.run("echo hello from session 1-2")
	if err != nil {
		log.fatalf("failed to run command on session 1-2: %v", err)
	}
	// 创建第二个会话
	session2, err := client.newsession()
	if err != nil {
		log.fatalf("failed to create session 2: %v", err)
	}
	defer session2.close()
	// 执行第二个命令
	fmt.println("executing command on session 2")
	err = session2.run("echo hello from session 2")
	if err != nil {
		log.fatalf("failed to run command on session 2: %v", err)
	}
	// 创建第三个会话
	session3, err := client.newsession()
	if err != nil {
		log.fatalf("failed to create session 3: %v", err)
	}
	defer session3.close()
	// 执行第三个命令
	fmt.println("executing command on session 3")
	err = session3.run("echo hello from session 3")
	if err != nil {
		log.fatalf("failed to run command on session 3: %v", err)
	}
	fmt.println("all commands executed successfully")
}

package main
import (
    "golang.org/x/crypto/ssh"
    "log"
)
func main() {
    // 创建ssh配置--密码认证
    config := &ssh.clientconfig{
        user: "root",
        auth: []ssh.authmethod{
            ssh.password("1"), //密码认证
        },
        hostkeycallback: ssh.insecureignorehostkey(),
    }
     // 创建ssh配置--ssh密钥认证(生产环境下建议采用该方式) 二选一即可
	//config := &ssh.clientconfig{
    //user: "username",
    //auth: []ssh.authmethod{
    //    ssh.publickeysfromfile("path/to/private/key", "path/to/public/key"),
    //},
    //	hostkeycallback: ssh.fixedhostkey(hostkey),
	//}
    // 连接到远程服务器,并返回一个ssh客户端实例,
    /*
    	返回值类型:
    		*ssh.client
             error
    */
    client, err := ssh.dial("tcp", "192.168.56.160:22", config)
    if err != nil {
        log.fatalf("failed to dial: %v", err)
    }
    defer client.close()
    // 使用客户端创建一个ssh会话
    session, err := client.newsession()
    if err != nil {
        log.fatalf("failed to create session: %v", err)
    }
    defer session.close()
    // 在ssh会话中执行命令并输出命令结果
    out, err := session.combinedoutput("ls /export")
    if err != nil {
        log.fatalf("failed to run: %v", err)
    }
    log.printf("%s", out)
}

 注意事项:
       1、combinedoutput()函数剖析
	       func (s *ssh.session) combinedoutput(cmd string) ([]byte, error)
	           接收参数类型 string
	           返回值类型[]byte,error
	           将[]byte转换为string类型输出的结果为命令的执行结果
 		2、在一个session会话中执行多条命令的操作
	 		将多条命令保存在切片中,然后for循环将命令(value)传递给combinedoutput()函数即可
	 		// 示例命令
	 		commands := []string{"ls -l /tmp", "uptime", "df -h"} 
			for _, command := range commands {
				executecommand(client, command, ip, resultchan, &mu)
			}
			out, err := session.combinedoutput(commands)

package main
import (
    "golang.org/x/crypto/ssh"
    "log"
)
func main() {
    // 创建ssh配置--密码认证
    config := &ssh.clientconfig{
        user: "root",
        auth: []ssh.authmethod{
            ssh.password("1"), //密码认证
        },
        hostkeycallback: ssh.insecureignorehostkey(),
    }
    // 连接到远程服务器,并返回一个ssh客户端实例
    client, err := ssh.dial("tcp", "192.168.56.160:22", config)
    if err != nil {
        log.fatalf("failed to dial: %v", err)
    }
    defer client.close()
    // 使用客户端创建一个ssh会话
    session, err := client.newsession()
    if err != nil {
        log.fatalf("failed to create session: %v", err)
    }
    defer session.close()
    // 在ssh会话中执行命令并输出命令结果。
    out, err := session.combinedoutput("ls /var/log/")
    if err != nil {
        log.fatalf("failed to run: %v", err)
    }
    log.printf("out:%s\n", out)
}

注意事项:
	session.run(cmd string )error
	func (s *ssh.session) run(cmd string) error
	接收参数类型 string
	返回类型  error
	<如果要想获取到执行的结果和错误,即区分标准输出和标准错误,则使用下方的方法>

package main
import (
	"bytes"
	"fmt"
	"log"
	"golang.org/x/crypto/ssh"
)
// setupsshclient 配置并返回一个ssh客户端
func setupsshclient(user, password, host string, port int) (*ssh.client, error) {
	config := &ssh.clientconfig{
		user: user,
		auth: []ssh.authmethod{
			ssh.password(password),
		},
		hostkeycallback: ssh.insecureignorehostkey(), // 注意：这里使用了不安全的回调，仅用于示例。在实际应用中，你应该验证主机密钥。
	}
	client, err := ssh.dial("tcp", fmt.sprintf("%s:%d", host, port), config)
	if err != nil {
		return nil, err
	}
	return client, nil
}
func main() {
	user := "root"
	password := "1"
	host := "192.168.56.162"
	port := 22 // 默认ssh端口是22
	client, err := setupsshclient(user, password, host, port)
	if err != nil {
		log.fatalf("failed to setup ssh client: %v", err)
	}
	defer client.close()
	if host == "192.168.56.162" {
		newsession, _ := client.newsession()
		defer newsession.close()
		//run()
		// 创建一个缓冲区来捕获命令的输出
		var outputbuf bytes.buffer
		// 将标准输出和标准错误都重定向到同一个缓冲区
		newsession.stdout = &outputbuf
		newsession.stderr = &outputbuf
		err := newsession.run("ls /var/log/audit/")
		if err != nil {
			// 输出执行命令时的错误
			fmt.printf("error executing command: %v\n", err)
		}
		// 打印命令的输出（包括标准输出和标准错误）
		fmt.printf("command output:\n%s\n", outputbuf.string())
	}
}

注意事项:
	func (s *ssh.session) start(cmd string) error
        接收参数类型 string
        返回类型  error
        如果要想获取到执行的结果和错误,即区分标准输出和标准错误,则使用下方的方法
     func (s *ssh.session) wait() error
        返回类型  error
  		等待
  	session.start() 单独使用时，命令会在后台执行，程序不会等待命令的完成，立即继续执行后续代码。
	session.start() 和 session.wait() 一起使用时，程序会在 wait() 处等待命令执行完成，之后才会继续执行后续的代码。

package main
import (
	"fmt"
	"golang.org/x/crypto/ssh"
	"log"
	"time"
)
func main() {
	// ssh 配置
	config := &ssh.clientconfig{
		user: "root", // 替换为远程服务器的用户名
		auth: []ssh.authmethod{
			ssh.password("1"), // 替换为远程服务器密码
		},
		hostkeycallback: ssh.insecureignorehostkey(), // 忽略主机密钥验证
	}
	// 连接远程服务器
	client, err := ssh.dial("tcp", "192.168.56.160:22", config) // 替换为远程服务器的ip地址
	if err != nil {
		log.fatalf("failed to dial: %v", err)
	}
	defer client.close()
	// 创建会话
	session, err := client.newsession()
	if err != nil {
		log.fatalf("failed to create session: %v", err)
	}
	defer session.close()
	// 示例 1：使用 session.start() 启动命令，但不等待
	fmt.println("=== 示例 1: 使用 session.start() 启动命令，不等待 ===")
	err = session.start("sleep 5") // 启动一个后台命令
	if err != nil {
		log.fatalf("failed to start command: %v", err)
	}
	// 程序不会等待 sleep 5 执行完成，立即继续执行下一行
	fmt.println("命令已启动，程序继续执行，不等待命令结束")
	// 等待一段时间，观察命令是否执行完
	time.sleep(2 * time.second)
	fmt.println("程序在等待2秒后继续执行。")
	// 示例 2：使用 session.start() 启动命令，并等待命令执行完毕
	// 创建新的会话用于第二个命令
	session2, err := client.newsession()
	if err != nil {
		log.fatalf("failed to create session for second command: %v", err)
	}
	defer session2.close()
	fmt.println("\n=== 示例 2: 使用 session.start() 启动命令，并调用 session.wait() 等待 ===")
	err = session2.start("sleep 5") // 启动一个后台命令
	if err != nil {
		log.fatalf("failed to start second command: %v", err)
	}
	// 程序会在这里等待命令执行完成
	err = session2.wait() // 等待命令完成
	if err != nil {
		log.fatalf("failed to wait for command to finish: %v", err)
	}
	fmt.println("命令执行完成，程序继续执行")
	// 结束
	fmt.println("\n所有命令已执行完毕")
}

// 获取 标准输出和标准错误
stdout, _ := session.stdoutpipe()
output := make([]byte, 1024)
for {
	n, err := stdout.read(output)
	if err != nil {
		break
	}
	fmt.sprintf("stdout from %s: %s", ip, string(output[:n]))
}
stderr, err := session.stderrpipe()
output := make([]byte, 1024)
for {
	n, err := stderr.read(output)
	if err != nil {
		break
	}
	fmt.sprintf("stderr from %s: %s", ip, string(output[:n]))
}

1. 使用 `stdoutpipe` 和 `stderrpipe`:
	- `stdoutpipe()` 和 `stderrpipe()` 返回一个 `io.reader`，可以用来读取远程命令的标准输出（stdout）和标准错误输出（stderr）
 	- 可以通过从这些管道中读取数据来获取命令的输出，通常会使用协程来异步读取这些管道中的数据
2. 工作原理:
   - 首先通过 `session.stdoutpipe()` 和 `session.stderrpipe()` 获取输出的管道（`io.reader`）
   - 然后在程序中手动读取这些管道的内容，通常通过 `io.copy` 或者 `bufio.reader` 来处理流。
   - 这种方式适用于需要处理较大输出或需要实时读取命令输出的场景。
3. 优点:
   - 可以实时读取输出，因为管道是持续开放的，适合需要处理大量数据或逐行输出的情况。
   - 可以分别处理标准输出和标准错误，提供更多灵活性。
4. 缺点:
   - 需要异步读取标准输出和标准错误，可能需要更多的代码来确保并发处理和同步。
   - 适用于需要实时处理输出的场景，不适合简单的命令输出捕获。

....
// 创建一个缓冲区来捕获命令的输出
var outputbuf bytes.buffer
// 将标准输出和标准错误都重定向到同一个缓冲区
session.stdout = &outputbuf
session.stderr = &outputbuf
err := newsession.run("ls /var/log/audit/")
if err != nil {
    // 输出执行命令时的错误
    fmt.printf("error executing command: %v\n", err)
}
// 打印命令的输出（包括标准输出和标准错误）
fmt.printf("command output:\n%s\n", outputbuf.string())
...

1. 使用 `newsession.stdout` 和 `newsession.stderr`:
   - `session.stdout` 和 `session.stderr` 分别是 `io.writer` 类型，允许将命令的标准输出和标准错误直接写入一个缓冲区（如 `bytes.buffer`）。
   - 可以通过 `outputbuf.string()` 获取完整的命令输出。这里，`stdout` 和 `stderr` 都被重定向到同一个 `bytes.buffer`，
   - 这样就能捕获命令的所有输出（无论是标准输出还是标准错误）。
2. 工作原理:
   - `session.run()` 会直接执行命令并把标准输出和标准错误都写入到指定的缓冲区。
   - 不需要异步读取输出，命令执行完成后，只需要读取 `outputbuf` 即可获取所有输出。
3. 优点:
   - 代码简单，易于实现，适合捕获简单的命令输出。
   - 不需要显式地管理异步读取标准输出和错误流，适用于不需要实时处理输出的场景。
   - 适合于简单的任务（例如调试、输出日志等）并且输出数据量较小的情况。
4. 缺点:
   - 如果命令输出量大或者需要实时处理输出，可能会遇到缓冲区的限制或延迟。
   - 不能实时读取输出，必须等命令执行完毕才能获取所有输出。

1. 实时性:
   - `stdoutpipe` 和 `stderrpipe`:
   		适合实时读取标准输出和标准错误。可以在命令执行的过程中动态处理输出数据。
   - `stdout` 和 `stderr`:
   		适合捕获命令执行后的完整输出，并不实时读取。如果需要完整的命令输出，一次性获取比较简单。
2. 使用场景:
   - `stdoutpipe` 和 `stderrpipe`:
   		适合输出较大、需要流式处理的场景，比如你需要逐行读取或实时处理命令输出的场景。
   - `stdout` 和 `stderr`:
   		适合捕获命令的完整输出并一次性处理，代码简单，适合小规模的输出捕获。
3. 复杂性:
   - `stdoutpipe` 和 `stderrpipe`:
   		稍微复杂，因为需要处理并发读取输出流，可能涉及协程。
   - `stdout` 和 `stderr`:
   		简单易懂，适合不需要实时读取输出的情况。
根据实际需求，可以选择适合的方式:
	如果需要并发处理或实时处理输出流，使用 `stdoutpipe` 和 `stderrpipe`
	如果需要一次性获取完整输出,使用 `stdout` 和 `stderr` 会更加简洁。

package main
import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strings"
	"sync"
	"golang.org/x/crypto/ssh"
)
func executecommand(client *ssh.client, command string, ip string, resultchan chan<- string, mu *sync.mutex) {
	// 创建一个新的 ssh 会话
	session, err := client.newsession()
	if err != nil {
		log.println("failed to create session:", err)
		resultchan <- fmt.sprintf("error on %s: failed to create session", ip)
		return
	}
	defer session.close()
	// 获取 stdout 和 stderr 输出
	stdout, err := session.stdoutpipe()
	if err != nil {
		log.println("failed to get stdoutpipe:", err)
		resultchan <- fmt.sprintf("error on %s: failed to get stdoutpipe", ip)
		return
	}
	stderr, err := session.stderrpipe()
	if err != nil {
		log.println("failed to get stderrpipe:", err)
		resultchan <- fmt.sprintf("error on %s: failed to get stderrpipe", ip)
		return
	}
	// 启动命令
	err = session.start(command)
	if err != nil {
		log.println("failed to start command:", err)
		resultchan <- fmt.sprintf("error on %s: failed to start command", ip)
		return
	}
	// 使用锁来确保对共享资源（如输出的打印）是串行的
	mu.lock()
	defer mu.unlock()
	// 读取命令输出并打印到管道
	go func() {
		output := make([]byte, 1024)
		for {
			n, err := stdout.read(output)
			if err != nil {
				break
			}
			resultchan <- fmt.sprintf("stdout from %s: %s", ip, string(output[:n]))
		}
	}()
	go func() {
		output := make([]byte, 1024)
		for {
			n, err := stderr.read(output)
			if err != nil {
				break
			}
			resultchan <- fmt.sprintf("stderr from %s: %s", ip, string(output[:n]))
		}
	}()
	// 等待命令执行完毕
	err = session.wait()
	if err != nil {
		log.println("error executing command:", err)
		resultchan <- fmt.sprintf("error on %s: %v", ip, err)
	} else {
		resultchan <- fmt.sprintf("command executed successfully on %s", ip)
	}
}
func main() {
	// 加载 ip 地址文件
	file, err := os.open("/export/test/ips.txt")
	if err != nil {
		log.fatal("failed to open file:", err)
	}
	defer file.close()
	// 读取 ip 地址
	var ips []string
	scanner := bufio.newscanner(file)
	for scanner.scan() {
		ip := strings.trimspace(scanner.text())
		if ip != "" {
			ips = append(ips, ip)
		}
	}
	if err := scanner.err(); err != nil {
		log.fatal("failed to read file:", err)
	}
	// 设置 ssh 客户端配置，使用密码认证
	sshconfig := &ssh.clientconfig{
		user: "root", // ssh 用户名
		auth: []ssh.authmethod{
			ssh.password("1"), // 密码认证
		},
		hostkeycallback: ssh.insecureignorehostkey(), // 注意：生产环境中不建议使用此选项
	}
	// 创建一个管道用于接收结果
	resultchan := make(chan string, len(ips)*3) // 每台机器执行多个命令，调整管道容量
	var wg sync.waitgroup
	var mu sync.mutex // 创建锁
	// 遍历 ip 地址，并为每个 ip 地址启动一个 goroutine
	for _, ip := range ips {
		wg.add(1)
		go func(ip string) {
			defer wg.done()
			// 建立 ssh 连接
			client, err := ssh.dial("tcp", ip+":22", sshconfig)
			if err != nil {
				log.printf("failed to connect to %s: %v", ip, err)
				resultchan <- fmt.sprintf("failed to connect to %s", ip)
				return
			}
			defer client.close()
			// 对每台机器执行多个命令
			commands := []string{"ls -l /tmp", "uptime", "df -h"} // 示例命令
			for _, command := range commands {
				executecommand(client, command, ip, resultchan, &mu)
			}
		}(ip)
	}
	// 在所有任务完成之后关闭 resultchan
	go func() {
		wg.wait()
		close(resultchan)
	}()
	// 输出所有结果
	for result := range resultchan {
		fmt.println(result)
	}
}

涉及到的知识点:
	1、管道
	2、互斥锁
	3、goroutine并发
	4、ssh
	5、session.start/wait
	6、分开捕获标准输出和标准错误
	7、按行读取文件内容
上述代码示例演示了如何在多台机器上并发执行多个命令，并使用 sync.mutex 来保护共享资源（如管道）的访问
具体流程:
	1、从文件中按行读取ip并保存到切片ips中
	2、设置ssh配置,从管道中读取ip,将每个服务器连接和每个要执行的命令都放在一个 goroutine中。
		主程序继续启动新的 goroutine 执行任务,而不会因为某一台服务器的命令执行而导致整个程序阻塞
	3、将连接信息和捕获的标准输出和标准错误信息都写入到管道中
	4、当服务器连接成功后,调用执行命令函数executecommand,再该代码中的锁用于保护共享资源(resultchan)的访问
		因为如果多个 goroutine 同时向通道发送数据（比如日志输出）
			没有锁会导致输出混乱（多个 goroutine 的日志可能会交错，难以看清）
				使用 sync.mutex 来确保每次只有一个 goroutine 向通道发送数据，从而保证输出日志的顺序和一致性
					保证了多个 goroutine 在写入 resultchan 时不会互相干扰，避免了并发写入导致的数据不一致或错乱
	5、当所有远程机器的命令执行完成后,关闭会话、关闭通道,最终再打印出通道中所有的日志信息