简单实现通过输入指令，两步执行交换机命令。
- 输入执行换机的账号和密码。可以一次输入多个账号和密码，为了方便操作，规定了输入格式。如 用户名；主机IP;密码|用户名；主机IP;密码。举例admin;192.168.56.10;h3csw1|admin;192.168.56.11;h3csw2
- 输入要执行的命令，以;分割。例如system-view;dis cu;
存在问题：
- 不够灵活。输入方式限制太死，输入特别字符也可能存在错误。
- 过于简陋。
- 功能简单。
不过我的目的已经达到，我主要是了解ssh的使用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
package main
import (
"bufio"
"fmt"
"golang.org/x/crypto/ssh"
"log"
"os"
"strings"
"sync"
)
//获取账号和密码的对应关系
type HostPassword struct {
Host string
Username string
Password string
}
var (
a,b string //临时存储变量
commands = []string{} //执行命令组
hp []HostPassword //保存账号和密码
wg sync.WaitGroup //执行goroutine
)
func main() {
//1. 选择交换机
//2. 输入要执行命令
//3. 建立会话连接
//4. 新建session，并执行命令
//1. 选择操作交换机
// 1.1 输入要执行交换机
fmt.Println("请输入计划执行命令的交换机账号和密码,账号密码直接使用|分割，多个账号密码之间使用;分割,例如admin;192.168.56.10;h3csw1|admin;192.168.56.11;h3csw2")
_, err := fmt.Scanln(&a)
if err != nil {
log.Fatal("输入错误:",err)
}
fmt.Println("请输入要执行的命令行，以；号间隔")
//1.1.1切割交换机命令
switchgroups := strings.Split(a, "|")
length := len(switchgroups)
hp = make([]HostPassword,length)
for i,singleswitch := range switchgroups{
hp[i]=HostPassword{}
switchsplit := strings.Split(singleswitch, ";")
hp[i].Username=switchsplit[0]
hp[i].Host=switchsplit[1]
hp[i].Password=switchsplit[2]
}
// 1.2 输入要执行命令
input := bufio.NewReader(os.Stdin)
b, err := input.ReadString('\n')
if err != nil {
log.Fatal("输入错误",err)
}
commands = strings.Split(b, ";")
//2. 执行交换机操作
err = SshSwitch(hp)
if err != nil {
log.Fatalln(err)
}
// 同步等待
wg.Wait()
}
//建立ssh连接
func SshSwitch(hostpasswords []HostPassword) (error){
//循环获取hostpasswords的账号和密码
for i,_ := range hp{
//添加同步组，下面会执行goroutin
wg.Add(1)
config := &ssh.ClientConfig{
Config: ssh.Config{
Ciphers: []string{"aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-gcm@openssh.com", "arcfour256", "arcfour128", "aes128-cbc", "3des-cbc", "aes192-cbc", "aes256-cbc"},
}, //添加了很多加密方式，为了应对不同的密码规则
User: hp[i].Username,
Auth: []ssh.AuthMethod{
ssh.Password(hp[i].Password),
},
HostKeyCallback: ssh.InsecureIgnoreHostKey(), //此处相当于执行nil，但是并不安全
}
client, err := ssh.Dial("tcp",hp[i].Host+":22", config)
if err != nil {
log.Fatalln("建立ssh连接错误:",err)
return err
}
//执行goroutine，但是没有返回错误。
go HandleSession(client, commands,&wg)
}
return nil
}
//建立session，执行命令。
func HandleSession(client *ssh.Client,commands []string,wg *sync.WaitGroup) error {
//建立session
session, err := client.NewSession()
if err != nil {
log.Fatalln("创建session出错",err)
return err
}
//延迟关闭session
defer session.Close()
//设置terminalmodes的方式
modes := ssh.TerminalModes{
ssh.ECHO: 0, // disable echoing
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
//建立伪终端
err = session.RequestPty("xterm",80,40,modes)
if err != nil {
log.Fatal("创建requestpty出错",err)
return err
}
//设置session的标准输入是stdin
stdin, err := session.StdinPipe()
if err != nil {
log.Fatal("输入错误",err)
return err
}
//设置session的标准输出和错误输出分别是os.stdout,os,stderr.就是输出到后台
session.Stdout = os.Stdout
session.Stderr = os.Stderr
err = session.Shell()
if err != nil {
log.Fatal("创建shell出错",err)
return err
}
//将命令依次执行
for _, cmd := range commands {
fmt.Println(cmd)
_, err = fmt.Fprintf(stdin, "%s\n", cmd)
if err != nil {
log.Fatal("写入stdin出错",err)
return err
}
}
//执行等待
err = session.Wait()
if err != nil {
log.Fatal("等待session出错",err)
return err
}
//减少同步组的次数
wg.Done()
return nil
}
|
到此这篇关于Golang通过SSH执行交换机操作实现的文章就介绍到这了,更多相关Golang SSH执行交换机内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.51cto.com/9406836/2503197