Computer Network ဆိုတာ ဘာလဲ

နားလည်ထားရမယ့် အချက်

Computer network ဆိုတာ ကိုယ်ပိုင်လုပ်ဆောင်နိုင်တဲ့ စက်တွေ — host တွေ — ကို link တွေနဲ့ ချိတ်ဆက်ထားပြီး data ဖလှယ်နိုင်အောင် လုပ်ထားတဲ့ စနစ်တစ်ခု ဖြစ်ပါတယ်။ ကြားထဲက device တွေက အလုပ်နှစ်မျိုး လုပ်ပေးပါတယ်။ Switch က local network တစ်ခုတည်းအတွင်းမှာ host တွေကြား data ကို ရွှေ့ပေးပြီး၊ သူကိုယ်တိုင် သင်ယူမှတ်သားထားတဲ့ hardware address တွေကို ကြည့်ပြီး ဘယ်ကို ပို့ရမလဲ ဆုံးဖြတ်ပါတယ်။ Router ကတော့ network နှစ်ခုကြား နယ်နိမိတ်မှာ ရှိပြီး၊ data တစ်ခုကို နောက်ထပ် ဘယ် network ဆီ ပို့ရမလဲ ဆုံးဖြတ်ပေးပါတယ် — ဒါကို hop တစ်ခုချင်းစီ လုပ်သွားတာဖြစ်ပြီး device တစ်ခုတည်းက လမ်းကြောင်းတစ်ခုလုံးကို သိစရာ မလိုပါဘူး။

ပိုအရေးကြီးတဲ့ မေးခွန်းက data ဘယ်လို ခရီးသွားလဲ ဆိုတာပါ။ ဒီနေရာမှာ design နှစ်မျိုး ယှဉ်ပြိုင်ခဲ့ပါတယ်။ ရှေးဟောင်း တယ်လီဖုန်းစနစ် သုံးခဲ့တဲ့ circuit switching က မပို့ခင်ကတည်းက အစအဆုံး လမ်းကြောင်းတစ်ခုကို သီးသန့် ကြိုယူထားပါတယ်။ ဒီလမ်းကြောင်းက သင့်တစ်ဦးတည်းအတွက် ဖြစ်လို့ ခန့်မှန်းရလွယ်ပေမယ့်၊ စကားရပ်နေတဲ့ အချိန်တွေမှာလည်း ဆက်ပြီး ပိတ်ထားရလို့ အလွန် ဖြုန်းတီးမှု များပါတယ်။ Internet သုံးတဲ့ packet switching ကတော့ data ကို packet လို့ခေါ်တဲ့ လွတ်လပ်တဲ့ အပိုင်းငယ်လေးတွေအဖြစ် ဖြတ်ပြီး တစ်ခုချင်းစီ သီးခြား ပို့လိုက်ပါတယ်။ hop တစ်ခုစီက packet တစ်ခုလုံးကို သိမ်းယူ၊ စစ်ဆေး၊ ပြီးမှ ဆက်ပို့ပါတယ် — ဒါကို store-and-forward လို့ ခေါ်ပါတယ် — ဒါကြောင့် link တစ်ခုဟာ conversation အများကြီးရဲ့ packet တွေကို လှည့်ပတ်ပြီး သယ်ပေးနိုင်ပါတယ်။ ဒါက statistical multiplexing ဖြစ်ပါတယ် — sender အများစုဟာ အချိန်အများစုမှာ ငြိမ်နေတတ်လို့၊ မျှဝေသုံးတဲ့ link တစ်ခုက dedicated circuit တွေထက် အဆများစွာ ပိုပြီး conversation များများ သယ်နိုင်ပါတယ်။ resilience လည်း ရပါတယ် — သီးသန့် လမ်းကြောင်း မရှိတဲ့အတွက် router တစ်ခု ပျက်သွားရင် နောက်ပိုင်း packet တွေက အခြားလမ်းကြောင်းက သွားရုံပါပဲ၊ circuit ပျက်ရင်တော့ ခေါ်ဆိုမှု တစ်ခုလုံး သေသွားပါတယ်။

ကုန်ကျစရိတ်ကတော့ packet တွေဟာ နောက်ကျရောက်နိုင်တယ်၊ အစီအစဉ်လွဲပြီး ရောက်နိုင်တယ်၊ လုံးဝတောင် မရောက်နိုင်ဘူး ဆိုတာပါပဲ — ဒါတွေကို အထက် layer တွေက ရှင်းပေးပါတယ်။ packet တိုင်းရဲ့ ပုံစံကတော့ တူပါတယ် — router လိုအပ်တဲ့ control information (ဘယ်ကလာလဲ၊ ဘယ်ကို သွားမလဲ၊ ဘယ်လောက် ရှည်လဲ) ပါတဲ့ header နဲ့၊ ပြီးမှ သင် တကယ်ပို့ချင်တဲ့ bytes တွေဖြစ်တဲ့ payload တို့ ဖြစ်ပြီး၊ network က payload ထဲကို ဘယ်တော့မှ မကြည့်ပါဘူး။

TWO HOSTS, A SWITCH, A ROUTER, THE INTERNET
-------------------------------------------
   Host A                          Host B
 192.168.1.10                    192.168.1.11
      |                               |
      +-------------+   +-------------+
                    |   |
                +---+---+-----+
                |   SWITCH    |  Layer 2: moves frames between
                |  (one LAN)  |  hosts inside this one network
                +------+------+
                       |
                +------+------+
                |   ROUTER    |  Layer 3: picks the next network
                | 192.168.1.1 |  for each packet, one hop at a time
                +------+------+
                       |
                  (  INTERNET  )   many more routers, each one
                       |           making the same local choice
                +------+------+
                | web server  |
                |198.51.100.10|
                +-------------+

Every unit on those links has the same shape:

   +----------------+--------------------------------+
   |     HEADER     |            PAYLOAD             |
   | from / to / len|  the bytes you wanted to send  |
   +----------------+--------------------------------+
     routers read this      routers never look in here

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

ရုံးခန်းငယ်တစ်ခုကို စဉ်းစားကြည့်ပါ — laptop နှစ်လုံးနဲ့ printer တစ်လုံးက switch တစ်ခုမှာ တပ်ထားပြီး၊ switch က router မှာ တပ်ထားတယ်၊ router က internet ဘက်ကို မျက်နှာမူထားတယ်။ Laptop A က အများသုံး web server တစ်ခုမှာ စာမျက်နှာတစ်ခု ဖွင့်လိုက်တယ်။ A က 'from 192.168.1.10, to 198.51.100.10' လို့ ရေးထားတဲ့ header ပါတဲ့ packet အဖြစ် request ကို ပို့လိုက်တယ်။ Switch က hardware address တွေကိုပဲ ကြည့်ပြီး destination က local မဟုတ်မှန်း သိလို့ frame ကို router ဆီ ပို့လိုက်တယ်။ Router က header ထဲက destination IP ကို ဖတ်ပြီး routing table နဲ့ တိုက်ကာ နောက် network ဆီ ဆက်ပို့တယ် — payload ကိုတော့ လုံးဝ မဖွင့်ကြည့်ပါဘူး။ router တစ်ဒါဇင်လောက် ကျော်ပြီးမှ packet ရောက်သွားပြီး၊ ပြန်စာကလည်း အလားတူ လမ်းကြောင်းက ပြန်လာပါတယ်။

အခု packet-switched design က ဘာတွေ ပေးလဲ ဆိုတာ သတိထားကြည့်ပါ။ printer က တစ်ချိန်တည်းမှာ ပုံနှိပ်စာရွက် အကြီးကြီး spool လုပ်နေနိုင်ပါတယ်၊ သူ့ packet တွေက web request နဲ့ တူညီတဲ့ uplink ပေါ်မှာ လှည့်ပတ်သွားနေပြီး၊ ဘယ်သူမှ line ကို သီးသန့် ကြိုယူမထားပါဘူး။ အလယ်ခေါက်မှာ အထက်ပိုင်း router တစ်ခု ပျက်သွားရင်၊ ပို့ပြီးသား packet တွေ ပျောက်ပေမယ့် နောက်ပိုင်း packet တွေက ပျက်တဲ့နေရာကို ရှောင်ပြီး သွားကာ TCP layer က ပျောက်သွားတာတွေကို ပြန်ပို့ပေးပါတယ် — အသုံးပြုသူက ခဏ ရပ်သွားတာလောက်ပဲ မြင်ရပြီး connection သေသွားတာ မဟုတ်ပါဘူး။ Circuit switching ဆိုရင် ဒီနှစ်ခုစလုံး ဇာတ်လမ်း ကွဲသွားပါလိမ့်မယ် — printer က သူ့အတွက် သီးသန့် capacity လိုအပ်မှာဖြစ်ပြီး၊ router ပျက်တာက ခေါ်ဆိုမှုတစ်ခုလုံးကို ဖြတ်ချပစ်မှာ ဖြစ်ပါတယ်။

• Switch က local network အတွင်း၊ router က network တွေကြားမှာ ပို့ပေးတယ်
• Packet switching က store-and-forward နဲ့ statistical multiplexing ကြောင့် အနိုင်ရခဲ့တယ်
• Packet တိုင်းက header (control) နဲ့ payload (data) နှစ်ပိုင်း ဖြစ်တယ်

အတူတူ စမ်းရေးကြည့်မယ်

import struct

# A toy packet = fixed-size header + variable-length payload.
# Header layout, network byte order ("!" = big-endian):
#   version   1 byte  (B)
#   ttl       1 byte  (B)
#   src_port  2 bytes (H)
#   dst_port  2 bytes (H)
#   total_len 2 bytes (H)
HEADER = "!BBHHH"
HDR_SIZE = struct.calcsize(HEADER)


def build_packet(payload):
    total = HDR_SIZE + len(payload)
    header = struct.pack(HEADER, 1, 64, 49152, 80, total)
    return header + payload


def parse_packet(raw):
    version, ttl, src, dst, total = struct.unpack(HEADER, raw[:HDR_SIZE])
    return {
        "version": version,
        "ttl": ttl,
        "src_port": src,
        "dst_port": dst,
        "total_len": total,
        "payload": raw[HDR_SIZE:],
    }


packet = build_packet(b"GET /index.html")

print("header size :", HDR_SIZE, "bytes")
print("packet size :", len(packet), "bytes")
print("on the wire :", packet.hex())
print()

fields = parse_packet(packet)
for key in ("version", "ttl", "src_port", "dst_port", "total_len"):
    print("%-10s = %s" % (key, fields[key]))
print("%-10s = %s" % ("payload", fields["payload"].decode()))
print()

# A router forwards using the header alone; the payload stays opaque.
print("router reads:", packet[:HDR_SIZE].hex())
print("router skips:", len(packet) - HDR_SIZE, "payload bytes")

header size : 8 bytes
packet size : 23 bytes
on the wire : 0140c00000500017474554202f696e6465782e68746d6c

version    = 1
ttl        = 64
src_port   = 49152
dst_port   = 80
total_len  = 23
payload    = GET /index.html

router reads: 0140c00000500017
router skips: 15 payload bytes

Cloudflare Learning Center — What is packet switching? — Computer Networking