एसएसएच सत्र की कुल विलंबता को मापें

Question

क्या सुरंगनुमा SSH सत्र में समग्र विलंबता को मापने / रिपोर्ट करने का कोई तरीका है ?

मेरा विशेष सेटअप है:

• ग्राहक (OS X + वाईफ़ाई राउटर + ADSL मॉडेम)
• गेटवे SSH सर्वर इंटरनेट से अवगत कराया
• आंतरिक SSH लक्ष्य जिसके लिए मैं सुरंग बना रहा हूं

मैं अपने स्थानीय मशीन पर कंसोल के बीच विलंबता और अंतिम मशीन को देखने के लिए इच्छुक हूं, जिस पर मेरे पास सत्र खुला है।

Comments

पहले सर्वर पर एसएसएच टनल क्यों नहीं, और फिर एसएसएच कंसोल दूसरे सर्वर पर।

— बर्ट

Answer 1

खुद ऐसा करने की कोशिश कर रहा था और इसी के साथ आया था। संभवत: एक सरल तरीका है, लेकिन यह वही है जो मैं लेकर आया हूं।

सबसे पहले, पाइप तैयार करें जिसका उपयोग एसएसएच कनेक्शन के माध्यम से बेंचमार्किंग प्रोग्राम को संवाद करने के लिए किया जाएगा।

$ mkfifo /tmp/up /tmp/down

फिर किसी दूरस्थ कमांड को निष्पादित किए बिना कंट्रोलमास्टर मोड में एक कनेक्शन स्थापित करें। यह हमें अंतःक्रियात्मक रूप से मेजबान के साथ प्रमाणित करने की अनुमति देता है। कनेक्शन स्थापित होने के बाद, SSH यहां अग्रभूमि में "लटका" देगा।

$ ssh $HOST -N -M -S /tmp/control

एक समानांतर टर्मिनल में, catपृष्ठभूमि में रिमोट निष्पादित करें । यह हमारा इको सर्वर होगा जिसकी विलंबता हम मापेंगे। इनपुट और आउटपुट फीफो से जुड़े हैं:

$ ssh $HOST -S /tmp/control cat </tmp/up >/tmp/down &

और फिर एक छोटा प्रोग्राम बेंचमार्क करें ( upFIFO को बाइट भेजें , downFIFO से एक बाइट प्राप्त करें ):

$ python -m timeit -s 'import os' \
    'os.write(3, "z"); z=os.read(4, 1); assert z=="z", "got %s" % z' \
    3>/tmp/up 4</tmp/down
10 loops, best of 3: 24.6 msec per loop

माप स्पष्ट रूप से गोल-यात्रा विलंबता को दर्शाता है। यदि आपको प्रयोग दोहराने की आवश्यकता है, तो अंतिम दो कमांड ( sshऔर python) फिर से चलाएं ।

यदि कुछ गलत लगता है, -vतो अधिक डिबगिंग आउटपुट प्राप्त करने के लिए SSH ध्वज का उपयोग करें ।

Answer 2

मैंने @ nicht-verstehen द्वारा सुझाए गए कुछ चरणों को छोड़ दिया:

python -m timeit --setup 'import subprocess; p = subprocess.Popen(["ssh", "user@host", "cat"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, bufsize=0)' 'p.stdin.write(b"z"); assert p.stdout.read(1) == b"z"'

कहाँ पे

python -m timeittimeitपायथन मॉड्यूल को कार्यान्वित करता है ।

-s/--setupविकल्प बताता है timeitजो कथन (नों) प्रत्येक दोहराने से पहले निष्पादित करने के लिए।

subprocess.Popen(["ssh", "user@host", "cat"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, bufsize=0)प्रक्षेपण ssh- catअपने मेजबान पर क्रियान्वित करना - एक बच्चे / उपप्रकार के रूप में, अपने आईओ धाराओं को पायथन फ़ाइल जैसी वस्तुओं पर पुनर्निर्देशित करना। bufsize=0यह सुनिश्चित करता है कि कोई IO बफर नहीं है, जिसके कारण IO प्रतीक्षा कर सकता है।

और प्रत्येक लूप के लिए:
p.stdin.write(b"z")बच्चे को एक बाइट लिखते हैं (बदले में ssh के माध्यम से cat)।
p.stdout.read(1)बच्चे से एक-एक बाइट पढ़ता है। इसके आस-पास का परीक्षण इस बात का परीक्षण करता है कि क्या यह बाइट वही है जो आपने इसे लिखा था।

एक ही चीज़ के लिए नीचे फोड़े, लेकिन नामित पाइप ( mkfifo) बनाने के लिए छोड़ देता है । मैंने देखा कि आप जितना अधिक लूप चलाते हैं, प्रत्येक लूप उतना ही तेज होता है। इसका उपयोग करके नियंत्रण करें -n/--number:python -m timeit --number 50 ...

Answer 3

sshpingउपयोगिता देखें : https://github.com/spook/sshping

उदाहरण:

# sshping 172.16.47.143
--- Login: 1725 msec
--- Minimum Latency: 4046 nsec
---  Median Latency: 11026 nsec  +/- 0 std dev
--- Average Latency: 178105 nsec
--- Maximum Latency: 8584886 nsec
---      Echo count: 1000 Bytes
---  Transfer Speed: 11694919 Bytes/second

# sshping --help
Usage: sshping [options] [user@]addr[:port]

  SSH-based ping that measures interactive character echo latency
  and file transfer throughput.  Pronounced "shipping".

Options:
  -c  --count NCHARS   Number of characters to echo, default 1000
  -e  --echocmd CMD    Use CMD for echo command; default: cat > /dev/null
  -h  --help           Print usage and exit
  -i  --identity FILE  Identity file, ie ssh private keyfile
  -p  --password PWD   Use password PWD (can be seen, use with care)
  -r  --runtime SECS   Run for SECS seconds, instead of count limit
  -t  --tests e|s      Run tests e=echo s=speed; default es=both
  -v  --verbose        Show more output, use twice for more: -vv

Answer 4

मेरा विचार इसके लिए टर्मिनल क्वेरी अनुक्रम का उपयोग करना था; लाभ यह है कि यह केवल सर्वर पर चलाया जा सकता है, नुकसान यह है कि यह टर्मिनल विलंबता को मापता है, न केवल कनेक्शन की विलंबता (लेकिन मुझे लगता है, आमतौर पर, नेटवर्क की देरी की तुलना में आपके टर्मिनल का प्रतिक्रिया समय नगण्य होगा) -Maybe यह भी आप समग्र विलंबता के साथ क्या मतलब है

#!/usr/bin/env python3
# Measure terminal latency (round-trip time) using "Query device code" command
from sys import stdin, stdout
import tty, termios, time

oldtty = termios.tcgetattr(stdin)
try:
    tty.setcbreak(stdout)

    runs = 10
    results = []
    for _ in range(runs):
        stdout.write("\x1b[c")
        stdout.flush()
        t1 = time.time()
        ch = stdin.read(1)
        assert(ch == '\x1b')
        t2 = time.time()
        while stdin.read(1) != 'c': # swallow rest of report
            continue
        latency = (t2 - t1) * 1000
        print('%.1fms' % (latency))
        results.append(latency)

    print()
    print('avg: %.1fms min: %.1fms max: %.1fms' % (
        sum(results) / runs,
        min(results),
        max(results)))
finally:
    termios.tcsetattr(stdin, termios.TCSADRAIN, oldtty)

(यह "डिवाइस कोड क्वेरी" का उपयोग करता है, सभी टर्मिनलों जो मैंने इस पर प्रतिक्रिया देने की कोशिश की है: xterm, alacritty, gnome-टर्मिनल। मैं खुद MacOS पर यह कोशिश नहीं कर सकता। इसलिए YMMV, यदि यह नहीं करता है, तो अनुरोधों में से एक और। टर्मिनल के बारे में कुछ जानकारी के बारे में पूछताछ कर सकते हैं, http://www.termsys.demon.co.uk/vtansi.htm देखें )

Comments

यह उत्तर अभी भी उन लोगों के लिए कुछ स्पष्टीकरण का उपयोग कर सकता है जो कि \x1b[c

— टिट्टी इंटर्नल से

यह सुनिश्चित नहीं है कि यह अनुकूल है, मुझे लगता है कि यह एक वैध चर्चा है: "डिवाइस स्थिति" से कोई भी शब्द termsys.demon.co.uk/vtansi.htm काम करेगा, जिसे देखते हुए टर्मिनल इसका समर्थन करता है, और मुझे नहीं पता कि क्या अच्छी तरह से समर्थित है, लेकिन मेरा अनुमान है कि मूल स्थिति क्वेरी होगी (नंगे हड्डियों में भी काम करता है)

— 1919 को