前言
这是一个轮子。
大家都知道 ansible 是功能超级强大的自动化运维工具，十分的高大上。太高大上了以至于在低端运维有点水土不服，在于三点：
所以造这个轮子的出发点是基于以下考虑的：
一点都没有黑 ansible 的意思。我们也有在用 ansible 来做自动化运维的工作，我觉得所有运维最好都学习下 ansible，将来总是要往自动化的方向走的。这个轮子的目的在于学习 ansible 之前，先有个够简单无脑的工具解决下眼前的需求~
建立 ssh 会话
go 自身不带 ssh 包。他的 ssh 包放在了 这里。import 他就好
import "golang.org/x/crypto/ssh"
首先我们需要建立一个 ssh 会话，比如这样。
我要评论
func connect(user, password, host, key string, port int, cipherlist []string) (*ssh.session, error) {
var (
auth []ssh.authmethod
addr string
clientconfig *ssh.clientconfig
client *ssh.client
config ssh.config
session *ssh.session
err error
)
// get auth method
auth = make([]ssh.authmethod, 0)
if key == "" {
auth = append(auth, ssh.password(password))
} else {
pembytes, err := ioutil.readfile(key)
if err != nil {
return nil, err
}
var signer ssh.signer
if password == "" {
signer, err = ssh.parseprivatekey(pembytes)
} else {
signer, err = ssh.parseprivatekeywithpassphrase(pembytes, []byte(password))
}
if err != nil {
return nil, err
}
auth = append(auth, ssh.publickeys(signer))
}
if len(cipherlist) == 0 {
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"},
}
} else {
config = ssh.config{
ciphers: cipherlist,
}
}
clientconfig = &ssh.clientconfig{
user: user,
auth: auth,
timeout: 30 * time.second,
config: config,
hostkeycallback: func(hostname string, remote net.addr, key ssh.publickey) error {
return nil
},
}
// connet to ssh
addr = fmt.sprintf("%s:%d", host, port)
if client, err = ssh.dial("tcp", addr, clientconfig); err != nil {
return nil, err
}
// create session
if session, err = client.newsession(); err != nil {
return nil, err
}
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
}
if err := session.requestpty("xterm", 80, 40, modes); err != nil {
return nil, err
}
return session, nil
}
ssh.authmethod 里存放了 ssh 的认证方式。使用密码认证的话，就用 ssh.password()来加载密码。使用密钥认证的话，就用 ssh.parseprivatekey() 或 ssh.parseprivatekeywithpassphrase() 读取密钥，然后通过 ssh.publickeys() 加载进去。
ssh.config 这个 struct 存了 ssh 的配置参数，他有以下几个配置选项，以下引用自godoc 。
type config struct {
// rand provides the source of entropy for cryptographic
// primitives. if rand is nil, the cryptographic random reader
// in package crypto/rand will be used.
// 加密时用的种子。默认就好
rand io.reader
// the maximum number of bytes sent or received after which a
// new key is negotiated. it must be at least 256. if
// unspecified, a size suitable for the chosen cipher is used.
// 密钥协商后的最大传输字节，默认就好
rekeythreshold uint64
// the allowed key exchanges algorithms. if unspecified then a
// default set of algorithms is used.
//
keyexchanges []string
// the allowed cipher algorithms. if unspecified then a sensible
// default is used.
// 连接所允许的加密算法
ciphers []string
// the allowed mac algorithms. if unspecified then a sensible default
// is used.
// 连接允许的 mac (message authentication code 消息摘要)算法，默认就好
macs []string
}
基本上默认的就好啦。但是 ciphers 需要修改下，默认配置下 go 的 ssh 包提供的 ciphers 包含以下加密方式
连 linux 通常没有问题，但是很多交换机其实默认只提供 aes128-cbc 3des-cbc aes192-cbc aes256-cbc 这些。因此我们还是加全一点比较好。
这里有两个地方要提一下
1、在 clientconfig 里有这么一段
hostkeycallback: func(hostname string, remote net.addr, key ssh.publickey) error {
return nil
},
这是因为默认密钥不受信任时，go 的 ssh 包会在 hostkeycallback 里把连接干掉（1.8 之后加的应该）。但是我们使用用户名密码连接的时候，这个太正常了不是么，所以让他 return nil 就好了。
2、在 newsession() 后，我们定义了 modes 和 requestpty。这是因为为之后使用 session.shell() 模拟终端时，所建立的终端参数。如果不配的话，默认值可能导致在某些终端上执行失败。例如一些 h3c 的交换机，连接建立后默认推出来的 copyright 可能会导致 ssh 连接异常，然后超时或者直接断掉。例如这样：
****************************************************************************** * copyright (c) 2004-2016 hangzhou h3c tech. co., ltd. all rights reserved. * * without the owner's prior written consent, * * no decompiling or reverse-engineering shall be allowed. * ******************************************************************************
配置的参数照搬 godoc 上的示例就好了：
// set up terminal modes
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
}
// request pseudo terminal
if err := session.requestpty("xterm", 40, 80, modes); err != nil {
log.fatal("request for pseudo terminal failed: ", err)
}
执行命令
建立起 session 后，执行命令就很简单了，用 session.run() 就可以执行我们的命令，结果则返回到 session.studout 里。我们跑个简单的测试。
const (
username = "admin"
password = "password"
ip = "192.168.15.101"
port = 22
cmd = "show clock"
)
func test_ssh_run(t *testing.t) {
ciphers := []string{}
session, err := connect(username, password, ip, port, ciphers)
if err != nil {
t.error(err)
return
}
defer session.close()
var stdoutbuf bytes.buffer
session.stdout = &stdoutbuf
session.run(cmd)
t.log(session.stdout)
return
}
目标是一台交换机，测试一下
=== run test_ssh_run --- pass: test_ssh_run (0.69s) ssh_test.go:30: 07:55:52.598 utc wed jan 17 2018 pass
可以看到 show clock 的命令已经成功执行了，并返回了结果。
session.run() 仅限定执行单条命令，要执行若干命令组合就需要用到 session.shell() 了。意思很明确，就是模拟一个终端去一条一条执行命令，并返回结果。就像我们用 shell 一样，我们把整过过程打印出来输出就好了。从 session.stdinpipe() 逐个输入命令，从session.stdout 和 session.stderr 获取 shell 上的输出。一样来做个测试。
const (
username = "admin"
password = "password"
ip = "192.168.15.101"
port = 22
cmds = "show clock;show env power;exit"
)
func test_ssh(t *testing.t) {
var cipherlist []string
session, err := connect(username, password, ip, key, port, cipherlist)
if err != nil {
t.error(err)
return
}
defer session.close()
cmdlist := strings.split(cmd, ";")
stdinbuf, err := session.stdinpipe()
if err != nil {
t.error(err)
return
}
var outbt, errbt bytes.buffer
session.stdout = &outbt
session.stderr = &errbt
err = session.shell()
if err != nil {
t.error(err)
return
}
for _, c := range cmdlist {
c = c + "\n"
stdinbuf.write([]byte(c))
}
session.wait()
t.log((outbt.string() + errbt.string()))
return
}
还是那台交换机，测试一下
=== run test_ssh
--- pass: test_ssh (0.69s)
ssh_test.go:51: sw-1#show clock
07:59:52.598 utc wed jan 17 2018
sw-1#show env power
sw pid serial# status sys pwr poe pwr watts
-- ------------------ ---------- --------------- ------- ------- -----
1 built-in good
sw-1#exit
pass
可以看到，两个命令都得到执行了，并在执行完 exit 后退出连接。
比较一下和 session.run() 的区别，可以发现在 session.shell() 模式下，输出的内容包含了主机的名字，输入的命令等等。因为这是 tty 执行的结果嘛。如果我们只需要执行命令倒也无所谓，但是如果我们还需要从执行命令的结果中读取一些信息，这些内容就显得有些臃肿了。比如我们在一台 ubuntu 上跑一下看看
=== run test_ssh
--- pass: test_ssh (0.98s)
ssh_test.go:50: welcome to ubuntu 16.04.3 lts (gnu/linux 4.4.0-98-generic x86_64)
* documentation: https://help.ubuntu.com
* management: https://landscape.canonical.com
* support: https://ubuntu.com/advantage
system information as of thu jan 18 16:34:56 cst 2018
system load: 0.0 processes: 335
usage of /: 10.0% of 90.18gb users logged in: 0
memory usage: 2% ip address for eth0: 192.168.80.131
swap usage: 0% ip address for docker0: 172.17.0.1
graph this data and manage this system at:
https://landscape.canonical.com/
16 个可升级软件包。
16 个安全更新。
new release '17.10' available.
run 'do-release-upgrade' to upgrade to it.
you have new mail.
last login: thu jan 18 16:31:41 2018 from 192.168.95.104
root@ubuntu-docker-node3:~# root@ubuntu-docker-node3:/opt# /opt
root@ubuntu-docker-node3:/opt# 注销
最起码，上面那一堆 system information 就用不着嘛。交换机是没有办法，linux 上能不能通过一条命令，也就是想办法 session.run() 来执行命令组合呢？
答案是可以的，把命令通过 && 连接起来就好了嘛。linux 的 shell 会帮我们拆开来分别运行的，比如上面的这个命令我们就可以合并成一条命令 cd /opt&&pwd&&exit
=== run test_ssh_run --- pass: test_ssh_run (0.91s) ssh_test.go:76: /opt
立马就简洁了对不对？
轮子
ssh 执行命令这样就差不多了。要变成一个可以用 ssh 批量操作工具，我们还要给他加上并发执行，并发限制，超时控制，输入参数解析，输出格式等等
这里就不展开了，最终这个造出来的轮子长这样：
可以直接命令行来执行，通过 ; 号或者 , 号作为命令和主机的分隔符。
也可以通过文本来存放主机组和命令组，通过换行符分隔。
特别的，如果输入的是 ip （-ips 或 -ipfile），那么允许 ip 地址段方式的输入，例如 192.168.15.101-192.168.15.110 。（还记得 swcollector 么，类似的实现方式）
支持使用 ssh 密钥认证，此时如果输入 password ，则为作为 key 的密码
对于 linux ，支持 linuxmode 模式，也就是将命令组合通过 && 连接后，使用 session.run() 运行。
也可以为每个主机定义不同的配置参数，以 json 格式加载配置。
# ./multissh -c ssh.json.example
输出可以打成 json 格式，方便程序处理。
# ./multissh -c ssh.json.example -j
也可以把输出结果存到以主机名命名的文本中，比如用来做配置备份
# ./multissh -c ssh.json.example -outtxt
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问， 点击进行留言回复！！
网友评论