Upload a file from aws s3 to linux server directly with private key - go

Question

There are some larger size files in AWS S3. I need to copy those files to a remote server.
I've tried with the below code, but I'm not able to transfer the file. Is this right way or I need to do in any other ways.
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/pkg/errors"
"github.com/tmc/scp"
"golang.org/x/crypto/ssh"
"io"
"io/ioutil"
"devtools/objectstorage"
"log"
"os"
)
func main() {
var osSecretKey = "secret-key"
var osAccessKeyID = "access-key"
var osRegion = "region"
var osUrl = "url"
var osBucketName = "bucket"
accpusr := "username"
accphost := "server"
sshport := "22"
scpDestinationPath := "/destination/path"
s3Config := objectstorage.S3Config{
AccessKeyID: osAccessKeyID,
SecretAccessKey: osSecretKey,
Region: osRegion,
Bucket: osBucketName,
URL: osUrl,
}
var s3FileName = "sample.txt"
var storage, err = objectstorage.New(s3Config)
if err != nil {
log.Fatal("failed to create s3 session", err)
}
dlObj, err := storage.Download(s3FileName)
if err != nil {
log.Fatal("failed to download s3 file", err)
}
log.Println("downloaded object")
err = Send(accpusr, accphost, sshport, scpDestinationPath, s3FileName, *dlObj.ContentLength, dlObj.Body)
if err != nil {
log.Fatal("failed to copy file", err)
}
log.Println("file copied successfully")
}
func Send(remoteUser, remoteHost, remoteSSHPort, remoteFolder, remoteFileName string, size int64, r io.Reader) error {
session, err := connect(remoteUser, remoteHost, remoteSSHPort)
if err != nil {
return err
}
defer session.Close()
err = scp.Copy(size, os.FileMode.Perm(0770), remoteFileName, r, remoteFolder, session)
if err != nil {
errMsg := fmt.Sprintf("Error sending file: %s", err.Error())
return errors.New(errMsg)
}
return nil
}
func connect(remoteUser string, remoteHost string, remoteSSHPort string) (*ssh.Session, error) {
//retrieve public key from private key
key, err := retrieveKey()
if err != nil {
return nil, err
}
var sshConfig ssh.Config
sshConfig.SetDefaults()
sshConfig.Ciphers = append(sshConfig.Ciphers, "aes256-cbc")
// Define the Client Config as:
config := &ssh.ClientConfig{
Config: sshConfig,
User: remoteUser,
Auth: []ssh.AuthMethod{
ssh.PublicKeys(key),
},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}
client, err := ssh.Dial("tcp", fmt.Sprintf("%s:%s", remoteHost, remoteSSHPort), config)
if err != nil {
errMsg := fmt.Sprintf("Error connecting to client: %s", err.Error())
return nil, errors.New(errMsg)
}
session, err := client.NewSession()
if err != nil {
errMsg := fmt.Sprintf("Error creating session: %s", err.Error())
return nil, errors.New(errMsg)
}
return session, nil
}
func retrieveKey() (key ssh.Signer, err error) {
scpCert := ""
buf, err := ioutil.ReadFile(fmt.Sprintf("%s", scpCert))
if err != nil {
errMsg := fmt.Sprintf("Error retrieving key: %s", err.Error())
return nil, errors.New(errMsg)
}
key, err = ssh.ParsePrivateKey(buf)
if err != nil {
errMsg := fmt.Sprintf("Error parsing key: %s", err.Error())
return nil, errors.New(errMsg)
}
return key, nil
}
objectstorage.New will return aws s3 session.
storage.Download will return s3.GetObjectOutput.