गो का उपयोग करके सैकड़ों सर्वर पर एसएसएच कमांड का निष्पादन

लेख किस बारे में है

इस अनुच्छेद में, हम एक सरल गो कार्यक्रम (100 लाइनों में) लिखेंगे जो सैकड़ों सर्वरों पर एसएसएच प्रोटोकॉल के माध्यम से कमांड निष्पादित कर सकते हैं, यह काफी प्रभावी ढंग से कर रहा है। इस कार्यक्रम को go.crypto / ssh - गो के लेखकों द्वारा SSH प्रोटोकॉल के कार्यान्वयन का उपयोग करके कार्यान्वित किया जाएगा।

इस लेख में लिखे गए कार्यक्रम का एक और अधिक "उन्नत" संस्करण एक गोथब पर उपलब्ध है जिसे गोएसएसएचए (गो एसएसएच एजेंट) कहा जाता है।

परिचय

जिस कंपनी के लिए मैं काम करता हूं, उसके पास 1 से थोड़ा अधिक सर्वर है, और एसएसएच प्रोटोकॉल का उपयोग करके हमारे सर्वरों की संख्या के साथ प्रभावी ढंग से काम करने के लिए, libssh2 पर आधारित लिबस्पर्श लाइब्रेरी लिखा गया था। यह लाइब्रेरी कई साल पहले सी का उपयोग करते हुए लिखा गया था, और अभी भी अपना काम अच्छी तरह से करता है, लेकिन इसे बनाए रखना बहुत मुश्किल है। इसके अलावा, Google की गो भाषा ने हमारी कंपनी सहित लोकप्रियता हासिल करना शुरू कर दिया है, इसलिए मैंने गो के साथ लिबस्पैश को बदलने और इसके कुछ कमियों को ठीक करने का प्रयास करने का फैसला किया, साथ ही साथ कोड और समर्थन की जटिलता को बहुत सरल किया।

आरंभ करने के लिए, हमें एक गो संकलक ( golang.org पर डाउनलोड के लिए उपलब्ध) और "go get" का उपयोग करके go.crypto / ssh डाउनलोड करने के लिए एक कार्यशील hg कमांड की आवश्यकता है।

शुरुआत हो रही है

कुछ निर्देशिका में "main.go" फ़ाइल बनाएँ, अधिमानतः खाली। अब हमारे प्रोग्राम की "रूपरेखा" लिखें, और फिर हम लेख के दौरान लापता कार्यों को कार्यान्वित करेंगे:

package main import ( "code.google.com/p/go.crypto/ssh" // ... ) // ... func main() { cmd := os.Args[1] //   - ,       hosts := os.Args[2:] //   (  ) -   results := make(chan string, 10) //        timeout := time.After(5 * time.Second) //  5    timeout   //       ssh.  makeKeyring()   config := &ssh.ClientConfig{ User: os.Getenv("LOGNAME"), Auth: []ssh.ClientAuth{makeKeyring()}, } //    goroutine (  OS thread)  ,  executeCmd()   for _, hostname := range hosts { go func(hostname string) { results <- executeCmd(cmd, hostname, config) }(hostname) } //     ,   "Timed out",      for i := 0; i < len(hosts); i++ { select { case res := <-results: fmt.Print(res) case <-timeout: fmt.Println("Timed out!") return } } } 

इस तथ्य के अलावा कि हमें MakeKeyring () और executeCmd () फ़ंक्शन लिखने की ज़रूरत है, हमारा कार्यक्रम तैयार है! "गो मैजिक" के लिए धन्यवाद, हम समानांतर में सभी सर्वरों के लिए एक कनेक्शन स्थापित करेंगे और उन पर दी गई कमांड को निष्पादित करेंगे, और किसी भी स्थिति में, स्क्रीन पर निष्पादित होने वाले सभी सर्वरों से परिणामों को प्रिंट करके 5 सेकंड में समाप्त होगा। चैनलों की अवधारणा और एक चुनिंदा निर्माण की उपस्थिति के कारण एक समान समयावधि को लागू करने का ऐसा सरल तरीका संभव है कि एक साथ कई चैनलों के बीच संचार की अनुमति मिलती है: जैसे ही एक मामले में कम से कम एक निर्माण को निष्पादित किया जा सकता है, उसी कोड ब्लॉक को निष्पादित किया जाएगा।

Go.crypto / ssh के लिए डेटा संरचनाओं की शुरुआत

हमने अभी तक MakeKeyring () और executeCmd () नहीं लिखा है, लेकिन सबसे अधिक संभावना है कि आपको यहां कुछ भी बहुत दिलचस्प नहीं लगेगा। हम केवल SSH कुंजी का उपयोग करके अधिकृत होंगे, और हम मान लेंगे कि कुंजियाँ .ssh / id_rsa या .ssh / id_dsa में स्थित हैं:

 type SignerContainer struct { signers []ssh.Signer } func (t *SignerContainer) Key(i int) (key ssh.PublicKey, err error) { if i >= len(t.signers) { return } key = t.signers[i].PublicKey() return } func (t *SignerContainer) Sign(i int, rand io.Reader, data []byte) (sig []byte, err error) { if i >= len(t.signers) { return } sig, err = t.signers[i].Sign(rand, data) return } func makeSigner(keyname string) (signer ssh.Signer, err error) { fp, err := os.Open(keyname) if err != nil { return } defer fp.Close() buf, _ := ioutil.ReadAll(fp) signer, _ = ssh.ParsePrivateKey(buf) return } func makeKeyring() ssh.ClientAuth { signers := []ssh.Signer{} keys := []string{os.Getenv("HOME") + "/.ssh/id_rsa", os.Getenv("HOME") + "/.ssh/id_dsa"} for _, keyname := range keys { signer, err := makeSigner(keyname) if err == nil { signers = append(signers, signer) } } return ssh.ClientAuthKeyring(&SignerContainer{signers}) } 

जैसा कि आप देख सकते हैं, हम ssh.ClientAuth इंटरफ़ेस लौटा रहे हैं, जिसमें सर्वर पर अधिकृत करने के लिए आवश्यक तरीके हैं। संक्षिप्तता के लिए, त्रुटि हैंडलिंग लगभग पूरी तरह से अनुपस्थित है, उत्पादन मोड में, कोड की मात्रा 1.5 गुना बड़ी होगी।

सर्वर पर कमांड निष्पादित करने के लिए, कोड भी बहुत तुच्छ है (त्रुटि हैंडलिंग संक्षिप्तता के लिए बाहर फेंक दिया जाता है):

 func executeCmd(cmd, hostname string, config *ssh.ClientConfig) string { conn, _ := ssh.Dial("tcp", hostname+":22", config) session, _ := conn.NewSession() defer session.Close() var stdoutBuf bytes.Buffer session.Stdout = &stdoutBuf session.Run(cmd) return hostname + ": " + stdoutBuf.String() } 

सादगी और संक्षिप्तता के लिए, हम हमेशा सर्वर पर प्राधिकरण के लिए वर्तमान उपयोगकर्ता नाम का उपयोग करते हैं, साथ ही डिफ़ॉल्ट रूप से पोर्ट 22।

हमारा कार्यक्रम तैयार है! प्रोग्राम का पूर्ण स्रोत कोड बिगाड़ने के तहत है:

हमारे आवेदन को लॉन्च करें:

 $ vim main.go #   :) $ go get #    $ time go run main.go 'hostname -f; sleep 4.7' localhost srv1 srv2 localhost: localhost srv1: srv1 Timed out! real 0m5.543s 

यह काम करता है! लोकलहोस्ट, srv1 और srv2 सर्वर के पास सभी कमांड को निष्पादित करने के लिए केवल 0.3 सेकंड थे, और धीमी srv2 सफल नहीं हुई। स्रोत से "मक्खी पर" कार्यक्रम को संकलित करने के साथ, कार्यक्रम में 5.5 सेकंड लगे, जिनमें से 5 सेकंड कमांड के लिए हमारा डिफ़ॉल्ट टाइमआउट था।

निष्कर्ष

लेख छोटा हो गया, लेकिन साथ ही हमने एक बहुत ही उपयोगी एप्लिकेशन भी लिखा, जिसे उत्पादन में सुरक्षित रूप से उपयोग किया जा सकता है। हमने उत्पादन वातावरण में इस एप्लिकेशन के अधिक उन्नत संस्करण का परीक्षण किया और इसने उत्कृष्ट परिणाम दिखाए।

संदर्भ:

1. गो भाषा: golang.org
2. go.crypto लाइब्रेरी: code.google.com/p/go/source/checkout?repo=crypto
3. गोएसएसहा (एसएसएचएन-प्रॉक्सी जेन्सन के माध्यम से बाहरी दुनिया के साथ संचार करता है): github.com/YuriyNasretdinov/GoSSHa