TCP/IP: คืออะไร, สแต็กโปรโตคอล และการส่งข้อมูล

TCP/IP คืออะไร?

TCP/IP (Transmission Control Protocol / Internet Protocol) คือสแต็กโปรโตคอลที่พัฒนาขึ้นในทศวรรษ 1970 สำหรับ ARPANET และได้กลายเป็นมาตรฐานโดยพฤตินัยสำหรับอินเทอร์เน็ตทั่วโลก โดยกำหนดวิธีการแบ่งข้อมูลเป็นแพ็กเก็ต ระบุที่อยู่ ส่ง และประกอบใหม่ที่ฝั่งผู้รับ

สถาปัตยกรรม TCP/IP สร้างขึ้นบนหลักการหลายชั้น โดยแต่ละชั้นจะทำหน้าที่นามธรรมเฉพาะ ชั้นแอปพลิเคชันทำงานกับข้อมูลแอปพลิเคชัน ชั้นขนส่งรับประกันความน่าเชื่อถือ ชั้นเครือข่ายจัดการการกำหนดเส้นทาง และชั้นลิงก์จัดการการส่งผ่านทางกายภาพ ความเป็นโมดูล ช่วยให้สามารถเปลี่ยนโปรโตคอลภายในชั้นได้โดยไม่กระทบต่อชั้นใกล้เคียง

ในการพัฒนาแอปมือถือ TCP/IP ถูกใช้โดยทุกแอปพลิเคชันที่ทำคำขอเครือข่าย ไลบรารีเช่น URLSession, OkHttp, AFNetworking และ Alamofire ทำงานบนสแต็กนี้ ซ่อนรายละเอียดการบรรจุแพ็กเก็ตและการกำหนดเส้นทางจากนักพัฒนา อย่างไรก็ตาม การเข้าใจ TCP/IP เป็นสิ่งจำเป็นสำหรับการปรับปรุงประสิทธิภาพ: การกำหนดค่าพารามิเตอร์ TCP ผ่าน URLSessionConfiguration ช่วยให้จัดการหมดเวลา รักษาการเชื่อมต่อ HTTP แบบถาวร และตั้งค่า proxys สำหรับสภาพแวดล้อมองค์กร

การเข้าใจ TCP/IP เป็นสิ่งจำเป็นสำหรับการวินิจฉัยปัญหาเครือข่าย: หากแอปพลิเคชันไม่สามารถเชื่อมต่อกับเซิร์ฟเวอร์ ปัญหาอาจอยู่ที่ชั้นใดก็ได้ของสแต็ก ตั้งแต่ช่องทางกายภาพไปจนถึงโปรโตคอลแอปพลิเคชัน เครื่องมือเช่น tcpdump, Wireshark และ Charles Proxy ช่วยให้วิเคราะห์การรับส่งข้อมูลในแต่ละชั้นและค้นหาจุดคอขวด สำหรับนักพัฒนาแอปมือถือ Xcode มี Network Debug Dashboard และ Android Studio มี Network Inspector สำหรับวิเคราะห์การเชื่อมต่อ TCP แบบเรียลไทม์

ชั้นของโมเดล TCP/IP

โมเดล TCP/IP ประกอบด้วยสี่ชั้น แต่ละชั้นทำหน้าที่ที่กำหนดอย่างเคร่งครัดระหว่างการส่งข้อมูล การเข้าใจลำดับชั้นนี้เป็นสิ่งจำเป็นสำหรับการวินิจฉัยปัญหาเครือข่ายและการปรับแต่งแอปพลิเคชัน

ชั้นแอปพลิเคชัน

ที่ชั้นแอปพลิเคชัน โปรโตคอลที่แอปพลิเคชันโต้ตอบโดยตรงทำงาน: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket ชั้นนี้จัดรูปแบบข้อมูลในแบบที่แอปพลิเคชันเข้าใจและส่งต่อไปยังชั้นขนส่ง นักพัฒนาแอปพลิเคชันมือถือทำงานที่ชั้นนี้ผ่านไลบรารีเครือข่าย

ชั้นขนส่ง

ชั้นขนส่งรับประกันการส่งข้อมูลระหว่างแอปพลิเคชันบนอุปกรณ์ต่างๆ โปรโตคอลหลักคือ TCP (การส่งที่เชื่อถือได้พร้อมการยืนยัน) และ UDP (การส่งที่รวดเร็วโดยไม่รับประกัน) TCP เพิ่มพอร์ตผู้ส่งและผู้รับให้กับข้อมูล จัดการลำดับแพ็กเก็ต และควบคุมความแออัดของเครือข่าย

ชั้นเครือข่ายและลิงก์

ชั้นเครือข่ายถูกใช้งานโดยโปรโตคอล IP ซึ่งกำหนดการระบุที่อยู่ (IPv4, IPv6) และการกำหนดเส้นทางแพ็กเก็ต แต่ละแพ็กเก็ตประกอบด้วยที่อยู่ IP ของผู้ส่งและผู้รับ และเราเตอร์ตามเส้นทางตัดสินใจเกี่ยวกับโหนดถัดไปตามตารางเส้นทาง IPv4 ใช้ที่อยู่ 32 บิต (ประมาณ 4.3 พันล้าน) ในขณะที่ IPv6 ใช้ที่อยู่ 128 บิต แก้ปัญหาการหมดที่อยู่

ชั้นลิงก์ทำงานกับสื่อส่งผ่านทางกายภาพ: Ethernet, Wi-Fi, Bluetooth ชั้นนี้แปลงแพ็กเก็ตเป็นสัญญาณและกลับกัน จัดการการเข้าถึงสื่อส่งผ่านผ่านที่อยู่ MAC และตรวจหาข้อผิดพลาดชั้นกายภาพโดยใช้ลำดับตรวจสอบเฟรม (FCS)

ที่ชั้นลิงก์ โปรโตคอลเช่น ARP (Address Resolution Protocol) ซึ่งแปลงที่อยู่ IP เป็นที่อยู่ MAC ของอุปกรณ์ในเครือข่ายท้องถิ่น และ PPP (Point-to-Point Protocol) ซึ่งใช้ในการเชื่อมต่อ VPN และเครือข่ายข้อมูลมือถือ ทำงาน

โปรโตคอล TCP ทำงานอย่างไร

TCP (Transmission Control Protocol) เป็นหนึ่งในโปรโตคอลหลักของชั้นขนส่ง โดยรับประกันการส่งสตรีมไบต์ที่เชื่อถือได้ เป็นลำดับ และตรวจสอบข้อผิดพลาดระหว่างแอปพลิเคชัน ก่อนส่งข้อมูล TCP จะสร้างการเชื่อมต่อผ่านการจับมือสามทาง

การจับมือสามทาง (three-way handshake) เริ่มต้นด้วยการส่งแพ็กเก็ต SYN โดยไคลเอนต์ เซิร์ฟเวอร์ตอบกลับด้วยแพ็กเก็ต SYN-ACK เพื่อยืนยันการรับ ไคลเอนต์ completes การจับมือด้วยแพ็กเก็ต ACK หลังจากนั้นการส่งข้อมูลจึงเริ่มต้น กระบวนการนี้รับประกันว่าทั้งสองฝ่ายพร้อมสำหรับการแลกเปลี่ยนและซิงโครไนซ์ตามหมายเลขลำดับ

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
response = sock.recv(4096)
print(response.decode())
sock.close()

ในตัวอย่าง ซ็อกเก็ต TCP ถูกสร้างขึ้นด้วยประเภท SOCK_STREAM ซึ่งทำการจับมือสามทางโดยอัตโนมัติเมื่อเรียก connect เมธอด send ส่งคำขอ HTTP และ recv รับการตอบกลับ หลังจากเสร็จสิ้น close ส่งแพ็กเก็ต FIN เพื่อปิดการเชื่อมต่ออย่างถูกต้อง

เซิร์ฟเวอร์ TCP พร้อมการจัดการไคลเอนต์

มาดูตัวอย่างเซิร์ฟเวอร์ TCP ใน Python ที่รับไคลเอนต์หลายตัวผ่านเธรด แต่ละการเชื่อมต่อถูกจัดการในเธรดแยกต่างหาก ทำให้สามารถให้บริการไคลเอนต์หลายตัวพร้อมกันโดยไม่บล็อกลูปหลัก

import socket
import threading

def handle_client(conn, addr):
    print(f'เชื่อมต่อไคลเอนต์แล้ว: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'ไคลเอนต์ {addr} ถูกตัดการเชื่อมต่อ')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('เซิร์ฟเวอร์ TCP เริ่มต้นบนพอร์ต 9090')

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

เซิร์ฟเวอร์ TCP จัดการแต่ละการเชื่อมต่อในเธรดแยกต่างหาก โดยเรียก accept ในลูปไม่สิ้นสุด ฟังก์ชัน handle_client รับข้อมูล แปลงเป็นตัวพิมพ์ใหญ่ และส่งกลับผ่าน sendall เมื่อลูป recv สิ้นสุด (เมื่อไคลเอนต์ปิดการเชื่อมต่อ) เธรดจะสิ้นสุดและซ็อกเก็ตจะปิดโดยอัตโนมัติ ในแอปพลิเคชันมือถือ การทำงานซ็อกเก็ตระดับต่ำดังกล่าวไม่ได้ใช้โดยตรง — ไลบรารี HTTP มือถือจัดการการเชื่อมต่อผ่านพูลเธรดและใช้การเชื่อมต่อ TCP ซ้ำโดยอัตโนมัติ

ความแตกต่างระหว่าง TCP และ UDP

การเลือกระหว่าง TCP และ UDP เป็นหนึ่งในการตัดสินใจสำคัญเมื่อออกแบบการสื่อสารเครือข่าย TCP รับประกันการส่งมอบ ลำดับ และความสมบูรณ์ของข้อมูลโดยแลกกับความหน่วงที่เพิ่มขึ้น UDP เสียสละความน่าเชื่อถือเพื่อความหน่วงต่ำสุดและภาระช่องสัญญาณที่น้อยลง

สำหรับแอปพลิเคชันมือถือ การเลือกโปรโตคอลขึ้นอยู่กับสถานการณ์: REST API และการโหลดข้อมูลต้องการ TCP ในขณะที่การโทรวิดีโอและเกมออนไลน์ได้รับประโยชน์จากความเร็วของ UDP แอปพลิเคชันบางตัวรวมทั้งสองโปรโตคอล — TCP สำหรับควบคุมและ UDP สำหรับสตรีมสื่อ โปรโตคอล QUIC ที่ทันสมัย ซึ่งทำงานบน UDP และใช้ใน HTTP/3 รวมข้อดีของทั้งสองแนวทางและรองรับบน iOS และ Android ผ่าน URLSession โดยอัตโนมัติ

ตัวอย่างโค้ด TCP/IP

มาดูตัวอย่างไคลเอนต์ TCP ใน Python พร้อมการจัดการข้อผิดพลาดและหมดเวลา วิธีการนี้ใช้ในแอปพลิเคชันมือถือสำหรับการเชื่อมต่อเซิร์ฟเวอร์ที่เชื่อถือได้

import socket
import sys

def tcp_client(host, port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(10)
        sock.connect((host, port))
        print(f'เชื่อมต่อไปยัง {host}:{port} แล้ว')
        return sock
    except socket.error as err:
        print(f'ข้อผิดพลาดการเชื่อมต่อ: {err}')
        sys.exit(1)

sock = tcp_client('api.example.com', 443)
sock.close()

ฟังก์ชัน tcp_client รับโฮสต์และพอร์ต สร้างซ็อกเก็ตด้วยหมดเวลา 10 วินาที และพยายามเชื่อมต่อ เมื่อเกิดข้อผิดพลาดการเชื่อมต่อ — เช่น เซิร์ฟเวอร์ไม่พร้อมใช้งานหรือไฟร์วอลล์บล็อก — จะมีการโยนข้อยกเว้นพร้อมคำอธิบายปัญหา ในแอปพลิเคชันมือถือ การหมดเวลาการเชื่อมต่อมีความสำคัญ: สั้นเกินไปนำไปสู่ข้อผิดพลาดเท็จบนเครือข่ายช้า ยาวเกินไปนำไปสู่การค้างของอินเทอร์เฟซ ค่าที่แนะนำสำหรับเครือข่ายมือถือคือ 10–15 วินาทีสำหรับ timeoutIntervalForRequest และ 30–60 วินาทีสำหรับ timeoutIntervalForResource ในการกำหนดค่า URLSession