Go语言实现ssh&scp的方法详解

目录

• 前言
• 连接远程服务器并执行命令（ssh）
• 拷贝远程服务器文件到本地（scp）
• 简单封装下

前言

最近遇到一个临时需求，需要将客户环境中一个服务每天的日志进行一系列复杂处理，并生成数据报表。由于数据处理逻辑复杂，且需要存入数据库，在客户环境使用 shell 脚本无法处理，因此就需要将日志先拷贝到本地，再进行处理；同时为了避免每天人工拷贝日志，需要实现自动化，整条链路自动执行，无需人工干预。平时使用 Go 语言较多，由此就引出了 Go 语言 ssh 连接远程客户服务器，并利用 scp 将数据拷贝下来的一系列操作。

说明：本文中的示例，均是基于Go1.17 64位机器

连接远程服务器并执行命令（ssh）

如下给出了使用 用户名+密码 的方式连接远程服务器并执行了 /usr/bin/whoami 命令的示例，步骤如下：

• 生成 ClientConfig：想要连接远程服务器，必须要至少指定一种实现了 Auth 的 AuthMethod，我们这里使用密码的方式；同时需要提供 一种用于安全校验远程服务端key的方法 HostKeyCallback，我们这里使用的是不校验的方式 ssh.InsecureIgnoreHostKey()，生产情况下建议使用 ssh.FixedHostKey(key PublicKey)；
• 调用 Dial ：Dial 方法与远程服务器建立连接，并返回一个 client ；
• NewSession：NewSession方法开启一个会话，在一个会话内可以通过 Run 方法执行一个命令。

import(
"bytes"
"fmt"
"log"

"golang.org/x/crypto/ssh"
)

funcmain(){

var(
username="yourusername"
password="yourpassword"
addr="ip:22"
)

config:=&ssh.ClientConfig{
User:username,
Auth:[]ssh.AuthMethod{
ssh.Password(password),
},
HostKeyCallback:ssh.InsecureIgnoreHostKey(),
}
client,err:=ssh.Dial("tcp",addr,config)
iferr!=nil{
log.Fatal("Failedtodial:",err)
}
deferclient.Close()

//开启一个session，用于执行一个命令
session,err:=client.NewSession()
iferr!=nil{
log.Fatal("Failedtocreatesession:",err)
}
defersession.Close()

//执行命令，并将执行的结果写到b中
varbbytes.Buffer
session.Stdout=&b

//也可以使用session.CombinedOutput()整合输出
iferr:=session.Run("/usr/bin/whoami");err!=nil{
log.Fatal("Failedtorun:"+err.Error())
}
fmt.Println(b.String())//root
}

上面的例子，我们在 Run 方法里面传入了一个命令，然后远程服务器会将执行结果返回给我们，如果是复杂操作，通过传入命令的方式就比较麻烦。比如上面提到的需求，需要我从 k8s 容器中拷贝出服务每天的日志，拆解后的步骤为：获取服务的多个 k8s pod 名称，根据当前日期，从多个容器中分别拷贝日志文件，然后整合成一个日志文件。针对复杂操作，我们可以在远程服务器编写一个脚本，然后 Run 方法中传入执行脚本的命令。

简单举个示例，我们在远程服务器编写了一个脚本 test.sh，放在了 /opt 目录下，脚本内容 与 调用方式分别如下：

#脚本文件
#!/bin/bash
today=$(date+"%Y-%m-%d")
#将数据写入文件
$(df-h>$today.log)

packagemain

import(
"fmt"
"log"

"golang.org/x/crypto/ssh"
)

funcmain(){

var(
username="yourusername"
password="yourpassword"
addr="ip:22"
)

config:=&ssh.ClientConfig{
User:username,
Auth:[]ssh.AuthMethod{
ssh.Password(password),
},
HostKeyCallback:ssh.InsecureIgnoreHostKey(),
}
client,err:=ssh.Dial("tcp",addr,config)
iferr!=nil{
log.Fatal("Failedtodial:",err)
}
deferclient.Close()


session,err:=client.NewSession()
iferr!=nil{
log.Fatal("Faiwww.devze.comledtocreatesession:",err)
}
defersession.Close()

//调用远程服务器脚本脚本
res,err:=session.CombinedOutput("sh/opt/test.sh")
iferr!=nil{
log.Fatal("Failedtorun:"+err.Error())
}
fmt.Println(string(res))

/*
FilesystemSizeUsedAvailUse%Mountedon
devtmpfs909M0909M0%/dev
tmpfs919M24K919M1%/dev/shm
tmpfs919M540K919M1%/run
tmpfs919M0919M0%/sys/fs/cgroup
/dev/vda150G6.9G40G15%/
tmpfs184M0184M0%/run/user/0
*/
}

拷贝远程服务器文件到本地（scp）

拷贝文件步骤比较简单：

• 建立 ssh client
• 基于 ssh client 创建 sftp client
• 打开远程服务器文件并拷贝到本地

packagemain

import(
"io"
"log"
"os"
"time"

"github.com/pkg/sftp"
"golang.org/x/crypto/ssh"
)

funcmain(){

var(
username="yourusername"
password="yourpassword"
addr="ip:22"
)

//1.建立sshclient
config:=&ssh.ClientConfig{
User:username,
Auth:[]ssh.AuthMethod{
ssh.Password(password),
},
HostKeyCallback:ssh.InsecureIgnoreHostKey(),
}
client,err:=ssh.Dial("tcp",addr,config)
iferr!=nil{
log.Fatal("Failedtodial:",err)
}
deferclient.Close()

//2.基于sshclient,创建sftp客户端
sftpClient,err:=sftp.NewClient(client)
iferr!=nil{
log.Fatal("Failedtoinitsftpclient:",err)
}
defersftpClient.Close()

//3.打开远程服务器文件
filename:=time.Now().Format("2006-01-02")+".log"
source,err:=sftpClient.Open("/opt/"+filename)
iferr!=nil{
log.Fatal("Failedtoopenremotefile:",err)
}
defersource.Close()

//4.创建本地文件
target,err:=os.OpenFile(filename,os.O_RdwR|os.O_CREATE|os.O_TRUNC,0644)
iferr!=nil{
log.Fatal("Failedtoopenlocalfile:",err)
}
defertarget.Close()

//5.数据复制
n,err:=io.Copy(target,source)
iferr!=nil{
log.Fatal("Failedtocopyfile:",err)
}
log.Println("Succeedtocopyfile:",n)

}

在 sftp client 中，还有许多方法，例如 Walk、ReadDir、Stat、Mkdir等，针对文件也有 Read、Write、WriteTo、pythonReadFrom等方法，像操作本地文件系统一样，非常便利。

简单封装下

packagemain

import(
"fmt"
"io"
"log"
"os"
"time"

"github.com/pkg/sftp"
"golang.org/x/crypto/ssh"
)

typeClistruct{
userstring
pwdstring
addrstring
client*ssh.Client
}


funcNewCli(user,pwd,addrstring)Cli{
returnCli{
user:user,
pwd:pwd,
addr:addr,
}
}

//Connect连接远程服务器
func(c*Cli)Connect()error{
config:=&ssh.ClientConfig{
User:c.user,
Auth:[]ssh.AuthMethod{
ssh.Password(c.pwd),
},
HostKeyCallback:ssh开发者_JAVA学习.InsecureIgnoreHostKey(),
}
client,err:=ssh.Dial("tcp",c.addr,config)
ifnil!=err{
returnfmt.Errorf("connectservererror:%w",err)
}
c.client=client
returnnil
}

//Run运行命令
func(cCli)Run(shellstring)(string,error){
ifc.client==nil{
iferr:=c.Connect();err!=nil{
return"",err
}
}

session,err:=c.client.NandroidewSession()
iferr!=nil{
return"",fmt.Errorf("createnewsessionerror:%w",err)
}
defersession.Close()

buf,err:=session.CombinedOutput(shell)
returnstring(buf),err
}

//Scp复制文件
func(cCli)Scp(srcFileName,targetFileNamestring)(int64,error){
ifc.client==nil{
iferr:=c.Connect();err!=nil{
return0,err
}
}

sftpClient,err:=sftp.NewClient(c.client)
iferr!=niwww.devze.coml{
return0,fmt.Errorf("newsftpclienterror:%w",err)
}
defersftpClient.Close()

source,err:=sftpClient.Open(srcFileName)
iferr!=nil{
return0,fmt.Errorf("sftpclientopenfileerror:%w",err)
}
defersource.Close()

target,err:=os.OpenFile(targetFileName,os.O_RDWR|os.O_CREATE|os.O_TRUNC,0644)
iferr!=nil{
return0,fmt.Errorf("openlocalfileerror:%w",err)
}
defertarget.Close()

n,err:=io.Copy(target,source)
iferr!=nil{
return0,fmt.Errorf("copyfileerror:%w",err)
}
returnn,nil
}


//调用测试
funcmain(){
var(
username="yourusername"
password="yourpassword"
addr="ip:22"
)

//初始化
client:=NewCli(username,password,addr)

//ssh并运行脚本
_,err:=client.Run("sh/opt/test.sh")
iferr!=nil{
log.Printf("failedtorunshell,err=[%v]\n",err)
rjseturn
}

//scp文件到本地
filename:=time.Now().Format("2006-01-02")+".log"
n,err:=client.Scp("/opt/"+filename,filename)
iferr!=nil{
log.Printf("failedtoscpfile,err=[%v]\n",err)
return
}
log.Printf("Succeedtoscpfile,size=[%d]\n",n)

//处理文件并删除本地文件......
}

通过上面的一系列操作，就可以实现了我的需求：

1.编写程序：

• 连接客户服务器
• 执行远程服务器的脚本，生成日志文件
• 拷贝远程服务器的日志文件到本地
• 处理日志文件
• 删除本地文件

2.在服务器上启动一个定时任务运行该程序

以上就是Go语言实现ssh&scp的方法详解的详细内容，更多关于Go语言实现ssh scp的资料请关注我们其它相关文章！