Golang SSH Client.

Fast and easy golang ssh client module.

Goph is a lightweight Go SSH client focusing on simplicity!

Installation ❘ Features ❘ Usage ❘ Examples ❘ License

🚀 Installation and Documentation

go get github.com/melbahja/goph

You can find the docs at go docs.

🤘 Features

Easy to use and simple API.
Supports known hosts by default.
Supports connections with passwords.
Supports connections with private keys.
Supports connections with protected private keys with passphrase.
Supports upload files from local to remote.
Supports download files from remote to local.
Supports connections with ssh agent (Unix systems only).
Supports adding new hosts to known_hosts file.
Supports file system operations like: Open, Create, Chmod...
Supports context.Context for command cancellation.

📄 Usage

Run a command via ssh:

package main
import ( 	"log" 	"fmt" 	"github.com/melbahja/goph" )
func main() {
// Start new ssh connection with private key. 	auth, err := goph.Key("/home/mohamed/.ssh/id_rsa", "") 	if err != nil { 		log.Fatal(err) 	}
client, err := goph.New("root", "192.1.1.3", auth) 	if err != nil { 		log.Fatal(err) 	}
// Defer closing the network connection. 	defer client.Close()
// Execute your command. 	out, err := client.Run("ls /tmp/")
if err != nil { 		log.Fatal(err) 	}
// Get your output as []byte. 	fmt.Println(string(out)) }

🔐 Start Connection With Protected Private Key:

auth, err := goph.Key("/home/mohamed/.ssh/idrsa", "youpassphrase_here")
if err != nil {
	// handle error
}
client, err := goph.New("root", "192.1.1.3", auth)

🔑 Start Connection With Password:

client, err := goph.New("root", "192.1.1.3", goph.Password("youpasswordhere"))

☛ Start Connection With SSH Agent (Unix systems only):

auth, err := goph.UseAgent()
if err != nil {
	// handle error
}
client, err := goph.New("root", "192.1.1.3", auth)

⤴️ Upload Local File to Remote:

err := client.Upload("/path/to/local/file", "/path/to/remote/file")

⤵️ Download Remote File to Local:

err := client.Download("/path/to/remote/file", "/path/to/local/file")

☛ Execute Bash Commands:

out, err := client.Run("bash -c 'printenv'")

☛ Execute Bash Command with timeout:

context, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
// will send SIGINT and return error after 1 second
out, err := client.RunContext(ctx, "sleep 5")

☛ Execute Bash Command With Env Variables:

out, err := client.Run(env MYVAR=&quot;MY VALUE&quot; bash -c &#39;echo $MYVAR;&#39;)

🥪 Using Goph Cmd:

Goph.Cmd struct is like the Go standard os/exec.Cmd.

// Get new Goph.Cmd
cmd, err := client.Command("ls", "-alh", "/tmp")
// or with context: // cmd, err := client.CommandContext(ctx, "ls", "-alh", "/tmp")
if err != nil { 	// handle the error! }
// You can set env vars, but the server must be configured to AcceptEnv line. cmd.Env = []string{"MY_VAR=MYVALUE"}
// Run you command. err = cmd.Run()

🗒️ Just like os/exec.Cmd you can run CombinedOutput, Output, Start, Wait, and ssh.Session methods like Signal...

📂 File System Operations Via SFTP:

You can easily get a SFTP client from Goph client:

sftp, err := client.NewSftp()
if err != nil { 	// handle the error! }
file, err := sftp.Create("/tmp/remote_file")
file.Write([]byte(Hello world)) file.Close()

🗒️ For more file operations see SFTP Docs.