golang标准库SSH操作示例

---

  

---

媒介

SSH 全称为 Secure Shell，是一种用于安全地远程登录到网络上的其他盘算机的网络协议。相信做运维的同砚没有不了解 SSH的，比较常用的登录服务器的 shell 工具例如 Xshell、SecureCRT、iTerm2 等都是基于 SSH 协议实现的。Golang 中的的 crypto/ssh 库提供了实现 SSH 客户端的功能，本文接下来详细讲解下怎样使用 Golang 实现操作 SSH 客户端,为后续运维开发的门路上使用golang编写脚本先夯实一下基础

---

一、了解SSH

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

复制代码

二、紧张知识点

1.安装ssh库

   代码如下（示例）：

1. go get golang.org/x/crypto/ssh

复制代码

2.ssh库紧张知识牢记

联合演示代码一起更好明确
   如下（示例）：

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

复制代码

  演示代码（示例）：

1. package main
3. import (
4.         "fmt"
5.         "golang.org/x/crypto/ssh"
6.         "log"
7. )
9. func main() {
10.         // SSH 配置
11.         config := &ssh.ClientConfig{
12.                 User: "root", // 替换为远程服务器的用户名
13.                 Auth: []ssh.AuthMethod{
14.                         ssh.Password("1"), // 替换为远程服务器密码
15.                 },
16.                 HostKeyCallback: ssh.InsecureIgnoreHostKey(), // 忽略主机密钥验证
17.         }
19.         // 连接远程服务器
20.         client, err := ssh.Dial("tcp", "192.168.56.160:22", config) // 替换为远程服务器的IP地址
21.         if err != nil {
22.                 log.Fatalf("Failed to dial: %v", err)
23.         }
24.         defer client.Close()
26.         // 创建第一个会话
27.         session1, err := client.NewSession()
28.         if err != nil {
29.                 log.Fatalf("Failed to create session 1: %v", err)
30.         }
31.         defer session1.Close()
33.         // 执行第一个命令
34.         fmt.Println("Executing command on session 1-1")
35.         err = session1.Run("echo Hello from session 1-1")
36.         if err != nil {
37.                 log.Fatalf("Failed to run command on session 1-1: %v", err)
38.         }
39.         // 演示在第一个会话中执行第二个命令看是否能成功
40.     fmt.Println("Executing command on session 1-2")
41.         err = session1.Run("echo Hello from session 1-2")
42.         if err != nil {
43.                 log.Fatalf("Failed to run command on session 1-2: %v", err)
44.         }
45.    
46.         // 创建第二个会话
47.         session2, err := client.NewSession()
48.         if err != nil {
49.                 log.Fatalf("Failed to create session 2: %v", err)
50.         }
51.         defer session2.Close()
53.         // 执行第二个命令
54.         fmt.Println("Executing command on session 2")
55.         err = session2.Run("echo Hello from session 2")
56.         if err != nil {
57.                 log.Fatalf("Failed to run command on session 2: %v", err)
58.         }
60.         // 创建第三个会话
61.         session3, err := client.NewSession()
62.         if err != nil {
63.                 log.Fatalf("Failed to create session 3: %v", err)
64.         }
65.         defer session3.Close()
67.         // 执行第三个命令
68.         fmt.Println("Executing command on session 3")
69.         err = session3.Run("echo Hello from session 3")
70.         if err != nil {
71.                 log.Fatalf("Failed to run command on session 3: %v", err)
72.         }
74.         fmt.Println("All commands executed successfully")
75. }

复制代码

执行这段代码,返回如下所示,在同一个会话下并行的运行两条下令,发现运行失败

当将1-2这段代码注释掉后,再次运行代码可以成功运行,跟上述的描述一致

三、模拟连接远程服务器并执行下令

演示怎么在golang中使用SSH库连接服务器并执行相应的linux下令

1. package main
3. import (
4.     "golang.org/x/crypto/ssh"
5.     "log"
6. )
8. func main() {
9.     // 创建SSH配置--密码认证
10.     config := &ssh.ClientConfig{
11.         User: "root",
12.         Auth: []ssh.AuthMethod{
13.             ssh.Password("1"), //密码认证
14.         },
15.         HostKeyCallback: ssh.InsecureIgnoreHostKey(),
16.     }
17.      // 创建SSH配置--SSH密钥认证(生产环境下建议采用该方式) 二选一即可
18.         //config := &ssh.ClientConfig{
19.     //User: "username",
20.     //Auth: []ssh.AuthMethod{
21.     //    ssh.PublicKeysFromFile("path/to/private/key", "path/to/public/key"),
22.     //},
23.     //        HostKeyCallback: ssh.FixedHostKey(hostKey),
24.         //}
25.        
26.     // 连接到远程服务器,并返回一个ssh客户端实例,
27.     /*
28.             返回值类型:
29.                     *ssh.Client
30.              error
31.     */
32.     client, err := ssh.Dial("tcp", "192.168.56.160:22", config)
33.     if err != nil {
34.         log.Fatalf("Failed to dial: %v", err)
35.     }
36.     defer client.Close()
38.     // 使用客户端创建一个ssh会话
39.     session, err := client.NewSession()
40.     if err != nil {
41.         log.Fatalf("Failed to create session: %v", err)
42.     }
43.     defer session.Close()
45.     // 在ssh会话中执行命令并输出命令结果
46.     out, err := session.CombinedOutput("ls /export")
47.     if err != nil {
48.         log.Fatalf("Failed to run: %v", err)
49.     }
50.     log.Printf("%s", out)
51. }

复制代码

四、SSH与os/exec标准库下执行下令的几种方式对比

方法功能描述阻塞/非阻塞输出捕获使用场景cmd:=exec.Command(“xx”,“x”)
err:=cmd.Run()执行本地下令并等候下令完成，返回错误阻塞不捕获输出（需用 Output/CombinedOutput 捕获）本地下令执行，等候下令完成err:=newsession.Run("xxx")执行远程下令并等候下令完成，返回错误阻塞不捕获输出（需手动捕获）远程 SSH 下令执行，等候完成cmd:=exec.Command(“xx”,“xx”)
cmd.Start()启动本地下令异步执行，不等候下令完成非阻塞,假如要阻塞,使用exec.Command().Wait()实现可通过 Stdout、Stderr 获取输出本地下令异步执行，非阻塞err:=newsession.Start("xx")启动远程下令异步执行，不等候下令完成非阻塞,适用于需要启动后台进程的场景,假如要阻塞使用,newsession.Wait()实现可通过 Stdout、Stderr 获取输出远程下令异步执行，非阻塞cmd:=exec.Command(“xx”,“x”)
out,err:=cmd.CombinedOutput()执行本地下令并捕获标准输出和标准错误的合并输出阻塞捕获标准输出和标准错误的合并输出本地下令执行，捕获全部输出out,err:=newsession.CombinedOutput("xx")执行远程下令并捕获标准输出和标准错误的合并输出阻塞捕获标准输出和标准错误的合并输出远程下令执行，捕获全部输出 五、SSH库下三种执行下令方式演示

5.1. session.CombinedOutput()示例

连接192.168.56.160服务器,并执行ls /var/log/下令查看目录下的文件

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

复制代码

1. package main
3. import (
4.     "golang.org/x/crypto/ssh"
5.     "log"
6. )
8. func main() {
9.     // 创建SSH配置--密码认证
10.     config := &ssh.ClientConfig{
11.         User: "root",
12.         Auth: []ssh.AuthMethod{
13.             ssh.Password("1"), //密码认证
14.         },
15.         HostKeyCallback: ssh.InsecureIgnoreHostKey(),
16.     }
17.     // 连接到远程服务器,并返回一个ssh客户端实例
18.     client, err := ssh.Dial("tcp", "192.168.56.160:22", config)
19.     if err != nil {
20.         log.Fatalf("Failed to dial: %v", err)
21.     }
22.     defer client.Close()
24.     // 使用客户端创建一个ssh会话
25.     session, err := client.NewSession()
26.     if err != nil {
27.         log.Fatalf("Failed to create session: %v", err)
28.     }
29.     defer session.Close()
31.     // 在ssh会话中执行命令并输出命令结果。
32.     out, err := session.CombinedOutput("ls /var/log/")
33.     if err != nil {
34.         log.Fatalf("Failed to run: %v", err)
35.     }
36.     log.Printf("out:%s\n", out)
37. }

复制代码

5.2. session.Run()示例

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

复制代码

1. package main
3. import (
4.         "bytes"
5.         "fmt"
6.         "log"
8.         "golang.org/x/crypto/ssh"
9. )
11. // setupSSHClient 配置并返回一个SSH客户端
12. func setupSSHClient(user, password, host string, port int) (*ssh.Client, error) {
13.         config := &ssh.ClientConfig{
14.                 User: user,
15.                 Auth: []ssh.AuthMethod{
16.                         ssh.Password(password),
17.                 },
18.                 HostKeyCallback: ssh.InsecureIgnoreHostKey(), // 注意：这里使用了不安全的回调，仅用于示例。在实际应用中，你应该验证主机密钥。
19.         }
20.         client, err := ssh.Dial("tcp", fmt.Sprintf("%s:%d", host, port), config)
21.         if err != nil {
22.                 return nil, err
23.         }
24.         return client, nil
25. }
26. func main() {
27.         user := "root"
28.         password := "1"
29.         host := "192.168.56.162"
30.         port := 22 // 默认SSH端口是22
31.         client, err := setupSSHClient(user, password, host, port)
32.         if err != nil {
33.                 log.Fatalf("Failed to setup SSH client: %v", err)
34.         }
35.         defer client.Close()
36.         if host == "192.168.56.162" {
37.                 newsession, _ := client.NewSession()
38.                 defer newsession.Close()
39.                 //Run()
40.                 // 创建一个缓冲区来捕获命令的输出
41.                 var outputBuf bytes.Buffer
42.                 // 将标准输出和标准错误都重定向到同一个缓冲区
43.                 newsession.Stdout = &outputBuf
44.                 newsession.Stderr = &outputBuf
45.                 err := newsession.Run("ls /var/log/audit/")
46.                 if err != nil {
47.                         // 输出执行命令时的错误
48.                         fmt.Printf("Error executing command: %v\n", err)
49.                 }
50.                 // 打印命令的输出（包括标准输出和标准错误）
51.                 fmt.Printf("Command output:\n%s\n", outputBuf.String())
52.         }
53. }

复制代码

5.3. session.Start()、session.Wait()示例

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

复制代码

1. package main
3. import (
4.         "fmt"
5.         "golang.org/x/crypto/ssh"
6.         "log"
7.         "time"
8. )
10. func main() {
11.         // SSH 配置
12.         config := &ssh.ClientConfig{
13.                 User: "root", // 替换为远程服务器的用户名
14.                 Auth: []ssh.AuthMethod{
15.                         ssh.Password("1"), // 替换为远程服务器密码
16.                 },
17.                 HostKeyCallback: ssh.InsecureIgnoreHostKey(), // 忽略主机密钥验证
18.         }
20.         // 连接远程服务器
21.         client, err := ssh.Dial("tcp", "192.168.56.160:22", config) // 替换为远程服务器的IP地址
22.         if err != nil {
23.                 log.Fatalf("Failed to dial: %v", err)
24.         }
25.         defer client.Close()
27.         // 创建会话
28.         session, err := client.NewSession()
29.         if err != nil {
30.                 log.Fatalf("Failed to create session: %v", err)
31.         }
32.         defer session.Close()
34.         // 示例 1：使用 session.Start() 启动命令，但不等待
35.         fmt.Println("=== 示例 1: 使用 session.Start() 启动命令，不等待 ===")
36.         err = session.Start("sleep 5") // 启动一个后台命令
37.         if err != nil {
38.                 log.Fatalf("Failed to start command: %v", err)
39.         }
40.         // 程序不会等待 sleep 5 执行完成，立即继续执行下一行
41.         fmt.Println("命令已启动，程序继续执行，不等待命令结束")
43.         // 等待一段时间，观察命令是否执行完
44.         time.Sleep(2 * time.Second)
45.         fmt.Println("程序在等待2秒后继续执行。")
47.         // 示例 2：使用 session.Start() 启动命令，并等待命令执行完毕
48.         // 创建新的会话用于第二个命令
49.         session2, err := client.NewSession()
50.         if err != nil {
51.                 log.Fatalf("Failed to create session for second command: %v", err)
52.         }
53.         defer session2.Close()
55.         fmt.Println("\n=== 示例 2: 使用 session.Start() 启动命令，并调用 session.Wait() 等待 ===")
56.         err = session2.Start("sleep 5") // 启动一个后台命令
57.         if err != nil {
58.                 log.Fatalf("Failed to start second command: %v", err)
59.         }
60.         // 程序会在这里等待命令执行完成
61.         err = session2.Wait() // 等待命令完成
62.         if err != nil {
63.                 log.Fatalf("Failed to wait for command to finish: %v", err)
64.         }
65.         fmt.Println("命令执行完成，程序继续执行")
67.         // 结束
68.         fmt.Println("\n所有命令已执行完毕")
69. }

复制代码

六、两种捕获标准输出和标准错误的方法：StdoutPipe / StderrPipe 和 session.Stdout / session.Stderr之间的区别

6.1. 使用 StdoutPipe 和 StderrPipe捕获标准输出和标准错误

   紧张代码示例

1. // 获取 标准输出和标准错误
2. stdout, _ := session.StdoutPipe()
3. output := make([]byte, 1024)
4. for {
5.         n, err := stdout.Read(output)
6.         if err != nil {
7.                 break
8.         }
9.         fmt.Sprintf("STDOUT from %s: %s", ip, string(output[:n]))
10. }
12. stderr, err := session.StderrPipe()
13. output := make([]byte, 1024)
14. for {
15.         n, err := stderr.Read(output)
16.         if err != nil {
17.                 break
18.         }
19.         fmt.Sprintf("STDERR from %s: %s", ip, string(output[:n]))
20. }

复制代码

解释

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

复制代码

6.2. 使用 重定向 session.Stdout 和 session.Stderr 捕获标准输出和标准错误

   紧张代码示例

1. ....
2. // 创建一个缓冲区来捕获命令的输出
3. var outputBuf bytes.Buffer
4. // 将标准输出和标准错误都重定向到同一个缓冲区
5. session.Stdout = &outputBuf
6. session.Stderr = &outputBuf
7. err := newsession.Run("ls /var/log/audit/")
8. if err != nil {
9.     // 输出执行命令时的错误
10.     fmt.Printf("Error executing command: %v\n", err)
11. }
12. // 打印命令的输出（包括标准输出和标准错误）
13. fmt.Printf("Command output:\n%s\n", outputBuf.String())
14. ...

复制代码

解释

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

复制代码

6.3.两种方式的区别

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

复制代码

七、示例: 连接到多台服务器并执行多个下令返回下令执行结果

先看代码再分析

1. package main
3. import (
4.         "bufio"
5.         "fmt"
6.         "log"
7.         "os"
8.         "strings"
9.         "sync"
11.         "golang.org/x/crypto/ssh"
12. )
14. func executeCommand(client *ssh.Client, command string, ip string, resultChan chan<- string, mu *sync.Mutex) {
15.         // 创建一个新的 SSH 会话
16.         session, err := client.NewSession()
17.         if err != nil {
18.                 log.Println("Failed to create session:", err)
19.                 resultChan <- fmt.Sprintf("Error on %s: Failed to create session", ip)
20.                 return
21.         }
22.         defer session.Close()
24.         // 获取 Stdout 和 Stderr 输出
25.         stdout, err := session.StdoutPipe()
26.         if err != nil {
27.                 log.Println("Failed to get StdoutPipe:", err)
28.                 resultChan <- fmt.Sprintf("Error on %s: Failed to get StdoutPipe", ip)
29.                 return
30.         }
32.         stderr, err := session.StderrPipe()
33.         if err != nil {
34.                 log.Println("Failed to get StderrPipe:", err)
35.                 resultChan <- fmt.Sprintf("Error on %s: Failed to get StderrPipe", ip)
36.                 return
37.         }
39.         // 启动命令
40.         err = session.Start(command)
41.         if err != nil {
42.                 log.Println("Failed to start command:", err)
43.                 resultChan <- fmt.Sprintf("Error on %s: Failed to start command", ip)
44.                 return
45.         }
47.         // 使用锁来确保对共享资源（如输出的打印）是串行的
48.         mu.Lock()
49.         defer mu.Unlock()
51.         // 读取命令输出并打印到管道
52.         go func() {
53.                 output := make([]byte, 1024)
54.                 for {
55.                         n, err := stdout.Read(output)
56.                         if err != nil {
57.                                 break
58.                         }
59.                         resultChan <- fmt.Sprintf("STDOUT from %s: %s", ip, string(output[:n]))
60.                 }
61.         }()
63.         go func() {
64.                 output := make([]byte, 1024)
65.                 for {
66.                         n, err := stderr.Read(output)
67.                         if err != nil {
68.                                 break
69.                         }
70.                         resultChan <- fmt.Sprintf("STDERR from %s: %s", ip, string(output[:n]))
71.                 }
72.         }()
74.         // 等待命令执行完毕
75.         err = session.Wait()
76.         if err != nil {
77.                 log.Println("Error executing command:", err)
78.                 resultChan <- fmt.Sprintf("Error on %s: %v", ip, err)
79.         } else {
80.                 resultChan <- fmt.Sprintf("Command executed successfully on %s", ip)
81.         }
82. }
84. func main() {
85.         // 加载 IP 地址文件
86.         file, err := os.Open("/export/test/ips.txt")
87.         if err != nil {
88.                 log.Fatal("Failed to open file:", err)
89.         }
90.         defer file.Close()
92.         // 读取 IP 地址
93.         var ips []string
94.         scanner := bufio.NewScanner(file)
95.         for scanner.Scan() {
96.                 ip := strings.TrimSpace(scanner.Text())
97.                 if ip != "" {
98.                         ips = append(ips, ip)
99.                 }
100.         }
101.         if err := scanner.Err(); err != nil {
102.                 log.Fatal("Failed to read file:", err)
103.         }
105.         // 设置 SSH 客户端配置，使用密码认证
106.         sshConfig := &ssh.ClientConfig{
107.                 User: "root", // SSH 用户名
108.                 Auth: []ssh.AuthMethod{
109.                         ssh.Password("1"), // 密码认证
110.                 },
111.                 HostKeyCallback: ssh.InsecureIgnoreHostKey(), // 注意：生产环境中不建议使用此选项
112.         }
114.         // 创建一个管道用于接收结果
115.         resultChan := make(chan string, len(ips)*3) // 每台机器执行多个命令，调整管道容量
116.         var wg sync.WaitGroup
117.         var mu sync.Mutex // 创建锁
119.         // 遍历 IP 地址，并为每个 IP 地址启动一个 goroutine
120.         for _, ip := range ips {
121.                 wg.Add(1)
122.                 go func(ip string) {
123.                         defer wg.Done()
124.                         // 建立 SSH 连接
125.                         client, err := ssh.Dial("tcp", ip+":22", sshConfig)
126.                         if err != nil {
127.                                 log.Printf("Failed to connect to %s: %v", ip, err)
128.                                 resultChan <- fmt.Sprintf("Failed to connect to %s", ip)
129.                                 return
130.                         }
131.                         defer client.Close()
133.                         // 对每台机器执行多个命令
134.                         commands := []string{"ls -l /tmp", "uptime", "df -h"} // 示例命令
135.                         for _, command := range commands {
136.                                 executeCommand(client, command, ip, resultChan, &mu)
137.                         }
138.                 }(ip)
139.         }
141.         // 在所有任务完成之后关闭 resultChan
142.         go func() {
143.                 wg.Wait()
144.                 close(resultChan)
145.         }()
147.         // 输出所有结果
148.         for result := range resultChan {
149.                 fmt.Println(result)
150.         }
151. }

复制代码

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

复制代码

总结

以上就是SSH标准库本身整理的知识,故不积跬步，无以至千里；不积小流，无以成江海,慢慢整理golang中运维可以使用到的相干库,向运维徐徐靠拢

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。