एसएसएच का उपयोग कर सर्वर से कनेक्ट करें और गोलांग

Question

के साथ एक पेम/कुंजी से कनेक्ट करें मैं गो प्रोग्रामिंग भाषा के [एसएसएच] [1] पैकेज का उपयोग करके एक कुंजी के साथ एक अमेज़ॅन एडब्ल्यूएस लिनक्स सर्वर से कनेक्ट करने का प्रयास कर रहा हूं। हालांकि पैकेज दस्तावेज थोड़ा सा गूढ़/भ्रमित है। क्या किसी को पता है कि एसएस के माध्यम से किसी कुंजी का उपयोग करके या कम से कम यदि यह संभव हो तो कैसे कनेक्ट करें? क्या मुझे परेशान है कि में [डायल] [3] उदाहरण यह कहता है

// An SSH client is represented with a ClientConn. Currently only 
// the "password" authentication method is supported. 

मैं मूल रूप से ssh मैं x.pem root@server.com व्यवहार की नकल और सर्वर के अंदर एक आदेश पर अमल करना चाहते हैं (उदाहरण के लिए whoami)

Answer 1

आप एक ssh.AuthMethod में ssh.Signers की एक सूची चालू करने के लिए ssh.PublicKeys उपयोग करने के लिए की जरूरत है। आप पेम बाइट्स से Signer प्राप्त करने के लिए ssh.ParsePrivateKey का उपयोग कर सकते हैं, या यदि आपको आरएसए, डीएसए या ecdsa निजी कुंजी का उपयोग करने की आवश्यकता है, तो आप उन्हें ssh.NewSignerFromKey पर दे सकते हैं।

यहां एक उदाहरण एजेंट समर्थन के साथ थोड़ा सा उदाहरण दिया गया है (चूंकि एक एजेंट का उपयोग करना आमतौर पर एक कुंजी फ़ाइल का उपयोग करने के बाद अगला कदम होता है)।

sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK")) 
if err != nil { 
    log.Fatal(err) 
} 

agent := agent.NewClient(sock) 

signers, err := agent.Signers() 
if err != nil { 
    log.Fatal(err) 
} 

// or get the signer from your private key file directly 
// signer, err := ssh.ParsePrivateKey(pemBytes) 
// if err != nil { 
//  log.Fatal(err) 
// } 

auths := []ssh.AuthMethod{ssh.PublicKeys(signers...)} 

cfg := &ssh.ClientConfig{ 
    User: "username", 
    Auth: auths, 
} 
cfg.SetDefaults() 

client, err := ssh.Dial("tcp", "aws-hostname:22", cfg) 
if err != nil { 
    log.Fatal(err) 
} 

session, err = client.NewSession() 
if err != nil { 
    log.Fatal(err) 
} 

log.Println("we have a session!") 

... 

Answer 2

यहाँ दूरस्थ रूप से अपने "सादे निजी कुंजी फ़ाइल" का उपयोग ls को चलाने के लिए एक उदाहरण है।

pemBytes, err := ioutil.ReadFile("/location/to/YOUR.pem") 
    if err != nil { 
     log.Fatal(err) 
    } 
    signer, err := ssh.ParsePrivateKey(pemBytes) 
    if err != nil { 
     log.Fatalf("parse key failed:%v", err) 
    } 
    config := &ssh.ClientConfig{ 
     User: "ubuntu", 
     Auth: []ssh.AuthMethod{ssh.PublicKeys(signer)}, 
    } 
    conn, err := ssh.Dial("tcp", "yourhost.com:22", config) 
    if err != nil { 
     log.Fatalf("dial failed:%v", err) 
    } 
    defer conn.Close() 
    session, err := conn.NewSession() 
    if err != nil { 
     log.Fatalf("session failed:%v", err) 
    } 
    defer session.Close() 
    var stdoutBuf bytes.Buffer 
    session.Stdout = &stdoutBuf 
    err = session.Run("ls -l") 
    if err != nil { 
     log.Fatalf("Run failed:%v", err) 
    } 
    log.Printf(">%s", stdoutBuf)