SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor

HTTP คืออะไร? สรุปพื้นฐานการทำงานสำหรับ Server Admin

เรียนรู้การทำงานของ HTTP สำหรับผู้ดูแลระบบเซิร์ฟเวอร์ ตั้งแต่การตีความ status code ใน access log ของ Nginx ไปจนถึงการตั้งค่า header และความแตกต่างของโปรโตคอล HTTP/3 กับ TLS

HTTP คืออะไร

HTTP (hypertext transfer protocol) คือชุดกฎเกณฑ์ที่ไคลเอนต์และเว็บเซิร์ฟเวอร์ใช้ในการร้องขอและส่งข้อมูลกลับหากัน ไคลเอนต์จะส่งคำขอซึ่งประกอบด้วย method เช่น GET, path เช่น /pricing, เวอร์ชันของโปรโตคอล, รายการของ header และบางครั้งอาจมี body ด้วย เซิร์ฟเวอร์จะตอบกลับด้วยรหัสสถานะ (status code) เช่น 200 ตามด้วย header ของเซิร์ฟเวอร์เองและมักจะมี body แนบมาด้วย การเข้าชมหน้าเว็บทุกครั้งและการเรียกใช้งาน API (application programming interface) บนเซิร์ฟเวอร์ของคุณคือการแลกเปลี่ยนข้อมูลในลักษณะนี้ที่เกิดขึ้นซ้ำๆ

HTTP ไม่มีสถานะในตัวมันเอง เซิร์ฟเวอร์จะไม่จดจำว่าคุณเพิ่งร้องขออะไรไปเมื่อครู่ ดังนั้นสิ่งใดก็ตามที่ทำหน้าที่เสมือนหน่วยความจำ เช่น session การเข้าสู่ระบบ จะถูกส่งผ่านไปใน header ของทุกคำขอ คุณสมบัติข้อนี้อธิบายถึงสิ่งที่จะกล่าวต่อไปได้เป็นอย่างดี นั่นคือการทำ caching จะขึ้นอยู่กับ header ทั้งหมด และ load balancer สามารถส่งคำขอถัดไปของคุณไปยัง backend อื่นได้โดยไม่ทำให้ระบบเกิดข้อผิดพลาด

เนื้อหาทั้งหมดด้านล่างนี้คือสิ่งที่โมเดลดังกล่าวปรากฏให้เห็นจากฝั่งเซิร์ฟเวอร์ ทั้งใน access log และใน nginx config ของคุณ

ตัวอย่างคำขอและคำตอบแบบดิบพร้อมคำอธิบาย

นี่คือตัวอย่างคำขอ HTTP/1.1 ที่สมบูรณ์ บรรทัดว่างจะเป็นตัวคั่นส่วนหัว (headers) และเนื้อหา (body) โดยปกติแล้ว GET จะไม่มีเนื้อหา

GET /pricing HTTP/1.1
Host: example.com
User-Agent: curl/8.5.0
Accept: */*
Accept-Encoding: gzip
  • GET คือ method ซึ่งระบุสิ่งที่ต้องการให้ทำ โดย GET ใช้สำหรับอ่านข้อมูล, POST ใช้สำหรับส่งข้อมูล, PUT ใช้สำหรับแทนที่ข้อมูล, DELETE ใช้สำหรับลบข้อมูล และ HEAD ใช้สำหรับขอเฉพาะส่วนหัวของ GET โดยไม่เอาเนื้อหา
  • /pricing คือ path ส่วน hostname จะไม่รวมอยู่ในบรรทัดคำขอ ซึ่งเป็นเหตุผลว่าทำไมจึงต้องมี header บรรทัดถัดไป
  • HTTP/1.1 คือเวอร์ชันของโปรโตคอลที่ไคลเอนต์ใช้งาน
  • Host: example.com ระบุชื่อเว็บไซต์ที่ไคลเอนต์ต้องการเข้าถึง HTTP/1.1 บังคับให้ต้องมีส่วนนี้ ดังนั้น nginx จะตอบกลับคำขอที่ไม่มีส่วนนี้ด้วย 400 Bad Request
  • ส่วนที่เหลือคือการตั้งค่าความต้องการ โดย Accept-Encoding: gzip ระบุว่าไคลเอนต์สามารถคลายการบีบอัดข้อมูลได้ เซิร์ฟเวอร์จึงได้รับอนุญาตให้บีบอัดเนื้อหาที่ส่งกลับไป

การตอบกลับมีรูปแบบเดียวกันโดยมีบรรทัดสถานะอยู่ด้านบน

HTTP/1.1 200 OK
Date: Thu, 06 Aug 2026 09:12:44 GMT
Server: nginx
Content-Type: text/html; charset=utf-8
Content-Length: 5310
Cache-Control: public, max-age=300

<!doctype html>...
  • 200 OK คือรหัสสถานะ (status code) พร้อมข้อความอธิบาย รหัสสถานะคือส่วนสำคัญ ส่วนข้อความอธิบายเป็นเพียงส่วนประกอบที่ไคลเอนต์มักจะละเลย
  • Content-Type บอกไคลเอนต์ว่าควรจัดการกับข้อมูลไบต์ที่ตามมาอย่างไร
  • Content-Length คือขนาดของเนื้อหาในหน่วยไบต์ เพื่อให้ไคลเอนต์ทราบจุดสิ้นสุดของเนื้อหา ในกรณีที่ไม่ทราบขนาดล่วงหน้า เซิร์ฟเวอร์จะส่ง Transfer-Encoding: chunked แทน และระบุจุดสิ้นสุดด้วย chunk ที่มีความยาวเป็นศูนย์
  • Cache-Control บอกเบราว์เซอร์และแคชระหว่างทางว่าสามารถถือว่าการตอบกลับนี้เป็นข้อมูลใหม่ได้นานเท่าใด เมื่อเวลาผ่านไปเกิน max-age วินาที ข้อมูลจะถือว่าเก่า (stale) ซึ่งไม่ได้หมายความว่าถูกลบ แคชอาจเก็บสำเนาที่เก่าไว้และตรวจสอบความถูกต้องกับเซิร์ฟเวอร์ของคุณอีกครั้งแทนการดาวน์โหลดเนื้อหาทั้งหมดใหม่
  • บรรทัดว่างหลังส่วนหัวทำหน้าที่แยกส่วนหัวออกจากเนื้อหา ทั้งในฝั่งคำขอและฝั่งตอบกลับ

ชื่อของ header ไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่ และทุกบรรทัดจะลงท้ายด้วย carriage return ตามด้วย line feed แทนที่จะเป็น newline ปกติ คุณไม่จำเป็นต้องพิมพ์สิ่งเหล่านี้ด้วยตัวเอง แต่คุณจะพบเห็นได้ในการดักจับแพ็กเก็ต (packet capture)

หากต้องการดูคู่คำขอและคำตอบจริง ให้รันคำสั่งนี้กับเว็บไซต์ที่คุณดูแล:

curl -sS -o /dev/null -D - https://example.com/

-D - จะเขียนส่วนหัวของการตอบกลับลงในเทอร์มินัลของคุณ และ -o /dev/null จะทิ้งเนื้อหาไป ควรเลือกใช้คำสั่งนี้แทน curl -I เพราะ -I จะส่งคำขอแบบ HEAD ออกไป ซึ่งหากแอปพลิเคชันเซิร์ฟเวอร์จัดการ HEAD ต่างจาก GET (ซึ่งหลายแห่งเป็นเช่นนั้น) คุณจะเห็นส่วนหัวที่ไม่มีเบราว์เซอร์ใดได้รับจริง ส่วน curl -v จะแสดงทั้งสองฝั่ง โดยบรรทัดคำขอจะถูกทำเครื่องหมายด้วย > และบรรทัดการตอบกลับจะถูกทำเครื่องหมายด้วย <

ลักษณะของ request line ใน access log ของ nginx

nginx มาพร้อมกับรูปแบบ log แบบ combined ซึ่งมีคำจำกัดความดังนี้:

log_format combined '$remote_addr - $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent"';

ตัวอย่างหนึ่งบรรทัดที่สร้างขึ้นจากรูปแบบดังกล่าว:

203.0.113.45 - - [06/Aug/2026:09:12:44 +0000] "GET /pricing HTTP/1.1" 200 5310 "https://example.com/" "Mozilla/5.0 (X11; Linux x86_64) Chrome/127.0.0.0 Safari/537.36"
  • 203.0.113.45 คือ $remote_addr ซึ่งเป็นที่อยู่ของผู้ที่เปิดการเชื่อมต่อ TCP (transmission control protocol) หากอยู่หลัง proxy ค่านี้จะเป็นที่อยู่ของ proxy ไม่ใช่ของผู้เข้าชม เว้นแต่คุณจะตั้งค่า realip module ตามที่อธิบายไว้ด้านล่างเพื่อแทนที่ค่าดังกล่าว
  • - ตัวแรกเป็นตัวยึดตำแหน่งแบบคงที่ ส่วนตัวที่สองคือ $remote_user ซึ่งจะถูกเติมข้อมูลเฉพาะเมื่อมีการใช้งาน HTTP basic authentication เท่านั้น
  • "GET /pricing HTTP/1.1" คือ $request ซึ่งเป็น request line ต้นฉบับทั้งหมด ด้วยการตั้งค่า log escaping เริ่มต้นของ nginx เครื่องหมายคำพูดคู่, backslash และไบต์ใดๆ ที่ต่ำกว่า 32 หรือสูงกว่า 126 จะถูกเขียนในรูปแบบ \xXX ดังนั้นบรรทัดที่ได้จะมีความถูกต้องตามข้อมูลจริง แต่อาจไม่ตรงกับไบต์ต่อไบต์เสมอไป
  • 200 คือสถานะที่เซิร์ฟเวอร์ของคุณส่งกลับ ไม่ใช่สถานะที่ผู้เข้าชมได้รับ
  • 5310 คือ $body_bytes_sent ซึ่งนับเฉพาะส่วน body เท่านั้น ไม่รวม response headers ดังนั้นตัวเลขนี้จึงน้อยกว่าจำนวนไบต์ที่ส่งออกไปจริงเสมอ
  • ฟิลด์ในเครื่องหมายคำพูดสองฟิลด์สุดท้ายคือ Referer และ User-Agent ทั้งสองค่ามาจากฝั่ง client จึงสามารถบรรจุข้อมูลอะไรก็ได้

ข้อมูลขยะจะถูกบันทึกลง log ด้วยในรูปแบบที่ถูก escape ไว้ หาก client พยายามสื่อสารด้วย TLS (transport layer security) มายังพอร์ต 80 ที่เป็น plaintext ของคุณ จะเกิดบรรทัด 400 ซึ่งฟิลด์ request จะขึ้นต้นด้วยไบต์ที่ถูก escape เช่น "\x16\x03\x01\x02\x00\x01" โดย \x16 คือประเภทของ TLS handshake record ดังนั้นไบต์เหล่านั้นจึงเป็นจุดเริ่มต้นของ ClientHello ไม่ใช่ request line แต่อย่างใด เซิร์ฟเวอร์ของคุณทำงานถูกต้องแล้ว เพียงแต่มีบางอย่างส่ง HTTPS มายังพอร์ต HTTP

ให้เพิ่ม $server_protocol ลงในรูปแบบ log ของคุณด้วย มันจะแสดงค่า HTTP/1.1, HTTP/2.0 หรือ HTTP/3.0 และเป็นวิธีที่เร็วที่สุดในการพิสูจน์ว่าการเปลี่ยนแปลงโปรโตคอลมีผลใช้งานจริงแล้ว

ความหมายของรหัสสถานะทั่วไปเมื่อเว็บไซต์ของคุณส่งกลับมา

เลขหลักแรกคือประเภทของรหัส ซึ่งเป็นสิ่งที่คุณควรพิจารณาก่อน

2xx หมายถึงการทำงานสำเร็จ 200 OK สำหรับการอ่านข้อมูลปกติ 201 Created หลังจากคำสั่ง POST ที่สร้างข้อมูลขึ้นมาใหม่ 204 No Content สำหรับความสำเร็จที่ไม่มีเนื้อหาต้องส่งกลับ ซึ่งเป็นคำตอบปกติสำหรับคำสั่ง DELETE

3xx หมายถึงให้ไปดูที่อื่น 301 เป็นการย้ายถาวรและเบราว์เซอร์จะแคชไว้อย่างแน่นหนา บางครั้งจนกว่าผู้ใช้จะล้างโปรไฟล์ของตนเอง ดังนั้นการตั้งค่า 301 ที่ชี้ไปยังชื่อโฮสต์ผิดจึงแก้ไขได้ยาก ให้ใช้ 302 ในขณะที่คุณยังอยู่ระหว่างการทดสอบการเปลี่ยนเส้นทาง 304 Not Modified คือความสำเร็จ ไม่ใช่ข้อผิดพลาด: ไคลเอนต์ส่งคำขอแบบมีเงื่อนไขมา โดยอาจเป็น If-None-Match ที่มี ETag (entity tag) ที่คุณยังรู้จักอยู่ หรือ If-Modified-Since ที่มีวันที่ซึ่งทรัพยากรนั้นไม่มีการเปลี่ยนแปลงตั้งแต่นั้นมา คุณจึงตอบกลับด้วยส่วนหัวโดยไม่มีเนื้อหา การที่ log เต็มไปด้วย 304 หมายความว่าการแคชกำลังทำงานได้ดี

4xx หมายถึงคำขอไม่ถูกต้อง 400 Bad Request คืออินพุตที่ผิดรูปแบบ 401 Unauthorized หมายถึงไม่ได้ยืนยันตัวตน และต้องมีส่วนหัว WWW-Authenticate ที่ระบุรูปแบบการยืนยันตัวตนไว้ 403 Forbidden หมายความว่าคำขอถูกเข้าใจแต่ถูกปฏิเสธ 404 Not Found คือ path ที่ไม่มีอยู่จริง หรือ path ที่เซิร์ฟเวอร์เลือกที่จะไม่เปิดเผยว่ามีอยู่ เพราะแอปพลิเคชันบางตัวตอบกลับด้วย 404 แทนที่จะเป็น 403 เพื่อซ่อนทรัพยากรจากไคลเอนต์ที่ไม่มีสิทธิ์เข้าถึง 405 Method Not Allowed คือการใช้ path ที่ถูกต้องแต่ผิด method ซึ่งเป็นสิ่งที่เกิดขึ้นเมื่อส่ง POST ไปยังตำแหน่งไฟล์แบบ static 413 คือเนื้อหาที่มีขนาดใหญ่กว่าค่า client_max_body_size ของ nginx ซึ่งโดยปกติคือ 1 megabyte และ log ข้อผิดพลาดจะยืนยันด้วย client intended to send too large body

รหัส 403 บนไฟล์ static มักเกิดจากระบบไฟล์มากกว่ากฎของ HTTP ให้อ่าน /var/log/nginx/error.log ก่อนที่จะเปลี่ยนการตั้งค่าใดๆ open() "/srv/site/index.html" failed (13: Permission denied) หมายความว่าผู้ใช้ nginx worker ไม่สามารถอ่านไฟล์ได้ ซึ่งมักเกิดจากไดเรกทอรีแม่ขาดสิทธิ์ execute สำหรับผู้อื่น directory index of "/srv/site/" is forbidden หมายความว่า path ที่ระบุเป็นไดเรกทอรีที่ไม่มีไฟล์ index ในขณะที่ autoindex ถูกปิดอยู่

5xx หมายถึงฝั่งของคุณมีปัญหา 500 เป็นข้อผิดพลาดทั่วไปของเซิร์ฟเวอร์ และบนเว็บไซต์ของคุณเอง มักชี้ไปที่ข้อผิดพลาดที่ไม่ได้จัดการในแอปพลิเคชันของคุณ 502 Bad Gateway หมายความว่า nginx ไม่สามารถรับการตอบกลับที่ใช้งานได้จาก upstream และ log ข้อผิดพลาดจะระบุสาเหตุ: connect() failed (111: Connection refused) while connecting to upstream หมายความว่าไม่มีบริการใดฟังอยู่ที่ address ใน proxy_pass 504 Gateway Timeout หมายความว่า nginx เลิกรอการตอบกลับจาก upstream กรณีทั่วไปคือ upstream ยอมรับการเชื่อมต่อแล้วไม่ตอบกลับภายใน proxy_read_timeout ซึ่งปกติคือ 60 วินาที โดย log จะบันทึกเป็น upstream timed out (110: Connection timed out) while reading response header from upstream ความพยายามเชื่อมต่อที่ไม่เสร็จสิ้นภายใน proxy_connect_timeout ซึ่งปกติคือ 60 วินาทีเช่นกัน จะจบลงด้วย 504 และบรรทัด log จะลงท้ายด้วย while connecting to upstream 503 Service Unavailable หมายความว่าเซิร์ฟเวอร์ไม่สามารถจัดการคำขอได้ชั่วคราว โดยปกติเนื่องจากโหลดเกินหรือปิดปรับปรุงตามกำหนดการ โปรดทราบว่าตัวจำกัดอัตรา (rate limiter) ของ nginx ส่งกลับ 503 เนื่องจาก limit_req_status มีค่าเริ่มต้นเป็น 503 หากคุณกำลังค้นหา 429 Too Many Requests ใน log ของคุณแต่พบ 503 แทน นี่คือสาเหตุ ให้ตั้งค่า limit_req_status 429; เพื่อให้ได้รหัสที่ถูกต้องแม่นยำ

ส่วนหัว (headers) ที่สำคัญเมื่อคุณรันเซิร์ฟเวอร์

Host ใช้สำหรับเลือกว่าจะเข้าถึงเว็บไซต์ใด IP address หนึ่งสามารถให้บริการชื่อโฮสต์ได้หลายร้อยชื่อ โดย nginx จะนำ Host มาเทียบกับ server_name เพื่อตัดสินใจว่าบล็อก server ใดจะเป็นผู้ตอบสนอง หากไม่มีชื่อใดตรงกัน nginx จะใช้เซิร์ฟเวอร์เริ่มต้น (default server) ซึ่งก็คือบล็อกแรกที่ฟังพอร์ตและที่อยู่ดังกล่าว เว้นแต่จะมีการระบุบล็อกอื่นเป็น default_server ไว้ ปัญหาการเข้าถึงเว็บไซต์ผิดพลาดเมื่อสร้าง virtual host ใหม่มักเกิดจากสาเหตุนี้เสมอ คือชื่อไม่ตรงกัน ทำให้คำขอถูกส่งต่อไปยังเซิร์ฟเวอร์เริ่มต้น คุณสามารถทดสอบได้โดยไม่ต้องแก้ไข DNS:

curl -sS -o /dev/null -D - -H 'Host: app.example.com' http://127.0.0.1/

User-Agent คือคำอธิบายตนเองที่ไคลเอนต์เขียนขึ้นมาและเป็นข้อความอิสระ ใช้สิ่งนี้เป็นเบาะแสเมื่ออ่าน log แต่อย่าใช้เป็นตัวควบคุม เพราะไคลเอนต์ที่ต้องการโกหกสามารถทำได้ง่าย ดังนั้นการบล็อก scraper ด้วย User-Agent จะกรองได้เฉพาะตัวที่สุภาพเท่านั้น

Content-Type เป็นตัวตัดสินว่าไบต์ข้อมูลจะถูกตีความอย่างไร เช่น application/json สำหรับคำขอ API หรือ text/html; charset=utf-8 สำหรับหน้าเว็บ nginx จะจับคู่ส่วนขยายไฟล์กับประเภทข้อมูลผ่าน /etc/nginx/mime.types และไฟล์ nginx.conf ที่มากับแพ็กเกจจะกำหนด default_type application/octet-stream; ไว้ ดังนั้นหากไฟล์มีส่วนขยายที่ nginx ไม่รู้จัก ระบบจะเสนอให้ดาวน์โหลดแทนที่จะแสดงผล อาการที่สังเกตได้คือหน้าเว็บที่โหลดขึ้นมาโดยไม่มีการจัดรูปแบบ (styling) ในขณะที่คอนโซลของเบราว์เซอร์จะแสดงข้อผิดพลาด Refused to apply style from ... because its MIME type ('text/plain') is not a supported stylesheet MIME type คำว่า MIME ย่อมาจาก multipurpose internet mail extensions ซึ่งเป็นระบบการตั้งชื่อสำหรับสตริงประเภทข้อมูลเหล่านี้

Cache-Control คือวิธีที่คุณใช้ควบคุมทุกแคชระหว่างเซิร์ฟเวอร์ของคุณกับผู้อ่าน public, max-age=31536000, immutable เหมาะสำหรับสินทรัพย์ (assets) ที่ชื่อไฟล์มี content hash กำกับอยู่ เพราะชื่อไฟล์จะเปลี่ยนไปเมื่อเนื้อหาเปลี่ยน no-store ควรใช้กับข้อมูลเฉพาะของผู้ใช้ เพราะแคชส่วนกลางที่เก็บหน้าเว็บที่ล็อกอินอยู่จะส่งข้อมูลนั้นให้คนถัดไปที่เรียกใช้ URL เดียวกัน private คือการตั้งค่าระดับกลาง: เบราว์เซอร์อาจเก็บไว้ได้ แต่แคชส่วนกลางห้ามเก็บ

X-Forwarded-For มีไว้เนื่องจากพร็อกซีจะซ่อนตัวตนของผู้เข้าชม เมื่อคำขอผ่าน reverse proxy แล้ว $remote_addr จะกลายเป็นที่อยู่ของพร็อกซี ทำให้ log, ข้อมูลตำแหน่งทางภูมิศาสตร์ และการจำกัดอัตรา (rate limiting) ของคุณมองเห็นไคลเอนต์เพียงรายเดียวจนกว่าคุณจะกู้คืนที่อยู่เดิม พร็อกซีจะต้องส่งต่อที่อยู่เดิมมาด้วย:

proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

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

set_real_ip_from 10.0.0.0/8;
real_ip_header X-Forwarded-For;

คำสั่งทั้งสองนี้เป็นส่วนหนึ่งของโมดูล realip ของ nginx ซึ่งจะแทนที่ $remote_addr ด้วยที่อยู่ที่ถูกส่งต่อมา และเก็บที่อยู่จริงของการเชื่อมต่อไว้ใน $realip_remote_addr หากคุณคอมไพล์ nginx ด้วยตนเอง ให้เพิ่ม --with-http_realip_module เข้าไปด้วย เนื่องจากโมดูลนี้ไม่ได้ถูกติดตั้งมาเป็นค่าเริ่มต้น

ให้ระบุเฉพาะช่วง IP ที่คุณควบคุมเท่านั้น X-Forwarded-For เป็นเพียงข้อความธรรมดาที่ไคลเอนต์ใดๆ ก็ส่งมาได้ ดังนั้น set_real_ip_from 0.0.0.0/0; จึงเปิดช่องให้ผู้เข้าชมกำหนดที่อยู่ที่คุณจะบันทึกลง log และที่อยู่ที่ตัวจำกัดอัตราของคุณจะนับได้

X-Forwarded-Proto ช่วยป้องกันความล้มเหลวที่เฉพาะเจาะจงและพบบ่อยมาก พร็อกซีของคุณทำ TLS termination และส่งต่อคำขอไปยังแอปพลิเคชันผ่าน HTTP ธรรมดา แอปพลิเคชันจะเห็นว่าเป็นคำขอธรรมดา จึงตัดสินใจว่าผู้เข้าชมควรอยู่บน HTTPS และตอบกลับด้วย 301 https://example.com/ เบราว์เซอร์จะทำตาม พร็อกซีจะทำ TLS termination อีกครั้งและส่งต่อ HTTP ธรรมดาไปอีก วนลูปเช่นนี้ไปเรื่อยๆ จนกระทั่งเบราว์เซอร์ยอมแพ้ด้วยข้อผิดพลาด ERR_TOO_MANY_REDIRECTS การส่ง X-Forwarded-Proto: https จะเป็นการบอกแอปพลิเคชันว่าผู้เข้าชมอยู่บน HTTPS แล้ว แอปพลิเคชันจึงหยุดการ redirect

HTTP/1.1 เทียบกับ HTTP/2 และ HTTP/3: สิ่งที่เปลี่ยนไปสำหรับคุณ

HTTP/1.1 เป็นโปรโตคอลแบบข้อความ ซึ่งในทางปฏิบัติจะจัดการคำขอได้ทีละรายการต่อหนึ่งการเชื่อมต่อ Connection: keep-alive ช่วยให้คำขอถัดไปสามารถใช้การเชื่อมต่อ TCP เดิมซ้ำได้ ซึ่งช่วยประหยัดค่าใช้จ่ายในการตั้งค่าการเชื่อมต่อ แต่การตอบกลับยังคงต้องส่งกลับมาตามลำดับที่ร้องขอ โปรโตคอลนี้ยังรองรับ pipelining ซึ่งไคลเอนต์สามารถส่งคำขอหลายรายการออกไปโดยไม่ต้องรอคำตอบ แต่กฎเรื่องลำดับยังคงมีผล และไม่มีเบราว์เซอร์สมัยใหม่ตัวใดเปิดใช้งาน pipelining เป็นค่าเริ่มต้น การตอบกลับที่ล่าช้าเพียงรายการเดียวจะขวางกั้นทุกอย่างที่ต่อคิวอยู่ด้านหลัง นี่คือปัญหา head-of-line blocking ซึ่งเบราว์เซอร์แก้ปัญหาด้วยการเปิดการเชื่อมต่อหลายรายการไปยัง hostname เดียวกันพร้อมกัน

HTTP/2 ยังคงใช้เมธอดและรหัสสถานะเดิม แต่เปลี่ยนรูปแบบการจัดเฟรมเป็นแบบไบนารี คำขอจำนวนมากสามารถใช้การเชื่อมต่อเดียวร่วมกันในฐานะสตรีมที่เป็นอิสระต่อกัน และข้อความส่วนหัวที่ซ้ำกันจะถูกบีบอัด ซึ่งมีความสำคัญเนื่องจากคำขอสมัยใหม่มีข้อมูลส่วนนี้อยู่มาก การเชื่อมต่อยังคงเป็น TCP ดังนั้นหากแพ็กเก็ตสูญหายเพียงหนึ่งรายการ จะทำให้ทุกสตรีมบนการเชื่อมต่อนั้นหยุดชะงักจนกว่าข้อมูลที่ส่งใหม่จะมาถึง ปัญหา head-of-line blocking จึงไม่ได้หายไป แต่ย้ายจากระดับ HTTP ลงไปอยู่ที่ระดับการขนส่ง (transport) ส่วน Server push เคยเป็นส่วนหนึ่งของ HTTP/2 แต่ในทางปฏิบัติได้ถูกยกเลิกไปแล้ว เนื่องจาก Chrome ได้ถอดการรองรับออกในปี 2022

HTTP/3 ยังคงใช้ความหมาย (semantics) เดิม แต่เปลี่ยนจาก TCP มาเป็น QUIC ซึ่งเป็นโปรโตคอลการขนส่งที่สร้างบน UDP (user datagram protocol) สตรีมของ QUIC เป็นอิสระต่อกันโดยสมบูรณ์ ดังนั้นแพ็กเก็ตที่สูญหายจะทำให้หยุดชะงักเฉพาะสตรีมที่แพ็กเก็ตนั้นสังกัดอยู่เท่านั้น TLS 1.3 ถูกรวมเข้าไว้ในขั้นตอนการจับมือ (handshake) ของ QUIC แทนที่จะวางซ้อนอยู่ด้านบน ทำให้การเชื่อมต่อใหม่ใช้ round trip น้อยลง ผลลัพธ์ในทางปฏิบัติมี 2 ประการ: พอร์ต UDP ที่เซิร์ฟเวอร์ของคุณใช้สำหรับ HTTP/3 จะต้องเปิดอยู่ในทุกไฟร์วอลล์บนเส้นทาง และเครือข่ายใดก็ตามที่จำกัดความเร็วหรือบล็อก UDP จะผลักดันให้ไคลเอนต์กลับไปใช้ HTTP/2 โดยปกติพอร์ตนี้คือ 443 แต่โปรโตคอลอนุญาตให้เซิร์ฟเวอร์ใช้พอร์ต UDP ใดก็ได้ เนื่องจากการประกาศที่ระบุให้เบราว์เซอร์ทราบถึง HTTP/3 จะระบุพอร์ตไว้อย่างชัดเจนเสมอ

สิ่งที่เปลี่ยนไปสำหรับคุณในทางปฏิบัติ: เบราว์เซอร์มักไม่เริ่มการเชื่อมต่อด้วย HTTP/3 โดยตรง แต่จะเชื่อมต่อผ่าน HTTP/2 หรือ HTTP/1.1 ก่อน จากนั้นจะเห็นส่วนหัว Alt-Svc: h3=":443"; ma=86400 ในการตอบกลับ แล้วจึงใช้ HTTP/3 สำหรับการเชื่อมต่อในภายหลังไปยังโฮสต์นั้น ข้อยกเว้นคือเรคคอร์ด HTTPS ใน DNS ที่ค่า alpn ระบุ h3 ซึ่งช่วยให้เบราว์เซอร์อย่าง Firefox สามารถเปิด HTTP/3 ได้ตั้งแต่การเชื่อมต่อครั้งแรก เรคคอร์ดดังกล่าวเป็นเพียงคำใบ้เพิ่มเติม ไม่ใช่สิ่งที่มาทดแทน ดังนั้นส่วนหัวจึงไม่ใช่สิ่งที่เลือกใส่หรือไม่ก็ได้ แต่เป็นกลไกหลักในการค้นหา ใน nginx นั้น HTTP/2 ได้กลายเป็น directive แยกต่างหากในเวอร์ชัน 1.25.1 (http2 on; ภายในบล็อก server ซึ่งมาแทนที่พารามิเตอร์ listen ... http2 แบบเดิม) และ QUIC ได้เข้ามาในเวอร์ชัน mainline 1.25.0 โดยไซต์ที่ใช้ HTTP/3 จำเป็นต้องมี listen 443 quic reuseport; ควบคู่ไปกับ listen 443 ssl; ตามปกติ โมดูล HTTP/3 ไม่ได้ถูกคอมไพล์มาเป็นค่าเริ่มต้น (--with-http_v3_module) และเอกสารของ nginx ยังคงระบุว่าการรองรับนี้อยู่ในขั้นทดลอง

พร็อกซีแต่ละตัวมีความพร้อมต่างกัน ซึ่งเป็นสิ่งที่ควรตรวจสอบกับเวอร์ชันที่คุณใช้งานจริง ณ เดือนพฤศจิกายน 2026 Caddy ให้บริการ HTTP/3 เป็นค่าเริ่มต้นโดยไม่ต้องตั้งค่าใดๆ ส่วน nginx ต้องการ listener แบบ quic ที่ชัดเจนรวมถึงส่วนหัว Alt-Svc ตามที่อธิบายข้างต้น Traefik เปิดใช้งานผ่านตัวเลือก http3 ที่ระบุในแต่ละ entry point หากคุณทำ TLS termination ที่ Traefik หน้าแอป Docker หลายตัว เวอร์ชันของโปรโตคอลที่ผู้เข้าชมได้รับจะถูกตัดสินใจที่จุดนั้น และการส่งต่อจากพร็อกซีไปยังคอนเทนเนอร์ของคุณมักจะเป็น HTTP/1.1 ปกติ ไม่ว่าเบราว์เซอร์จะเจรจาตกลงกันไว้อย่างไรก็ตาม

ควรตรวจสอบให้แน่ใจแทนการคาดเดา curl --http3 -sS -o /dev/null -D - https://example.com/ จะทำงานได้ก็ต่อเมื่อ curl -V ระบุ HTTP3 ไว้ในรายการฟีเจอร์ ซึ่งบิลด์ส่วนใหญ่ของดิสทริบิวชันมักไม่รวมฟีเจอร์นี้มาให้ วิธีตรวจสอบที่เชื่อถือได้ที่สุดคือดูจาก log ของคุณเอง: ให้เพิ่ม $server_protocol เข้าไปในรูปแบบ log แล้วอ่านดูว่าเบราว์เซอร์จริงเจรจาตกลงกันอย่างไร ก่อนจะทำขั้นตอนเหล่านั้น ให้ยืนยันก่อนว่าพอร์ต UDP ที่ listener ของ quic ของคุณใช้งานอยู่ (คือ 443 ใน config ด้านบน) นั้นเปิดอยู่จริง เพราะไฟร์วอลล์ที่อนุญาตเฉพาะ TCP 443 จะทำให้ HTTP/3 ล้มเหลวอย่างเงียบๆ ในขณะที่ไซต์ยังคงทำงานได้ผ่าน HTTP/2 การทราบว่า พอร์ตใดเปิดและกำลังฟังอยู่บนเซิร์ฟเวอร์ Linux ของคุณ คือสิ่งแรกที่ควรตรวจสอบ

HTTPS: HTTP คือโปรโตคอล, TLS คือส่วนห่อหุ้ม

HTTPS ไม่ใช่โปรโตคอลแยกต่างหาก แต่เป็นคำขอและรหัสสถานะชุดเดียวกันที่ถูกส่งผ่านภายในเซสชัน TLS โดยพอร์ต 80 จะส่งข้อมูลแบบไม่เข้ารหัส และพอร์ต 443 จะส่งข้อมูลแบบเข้ารหัส การทำ TLS handshake จะเสร็จสิ้นก่อน จากนั้นคำขอ HTTP จึงจะถูกส่งผ่านช่องทางที่เข้ารหัสไว้ ลำดับการทำงานนี้เป็นเหตุผลว่าทำไมปัญหาเกี่ยวกับใบรับรอง (certificate) จึงไม่มีรหัสสถานะกำกับ เพราะความล้มเหลวเกิดขึ้นก่อนที่จะมีการส่งไบต์ของ HTTP แม้แต่ไบต์เดียว จึงไม่มีการตอบกลับที่เป็นตัวเลข

รายละเอียดเรื่องลำดับความสำคัญมีความสำคัญมากบนเซิร์ฟเวอร์ที่โฮสต์หลายเว็บไซต์ ใบรับรองจะถูกเลือกโดยใช้ SNI (server name indication) ซึ่งเป็นฟิลด์ใน TLS handshake ที่ระบุชื่อโฮสต์แบบไม่เข้ารหัสก่อนที่จะมี HTTP header ใดๆ เกิดขึ้น ดังนั้นเซิร์ฟเวอร์จะเลือกใบรับรองจาก SNI ก่อน แล้วจึงเลือก virtual host จาก header Host เป็นลำดับถัดไป ทั้งสองส่วนนี้เป็นการค้นหาแยกจากกันซึ่งโดยปกติแล้วจะต้องตรงกัน หากไม่ตรงกัน เบราว์เซอร์จะแสดงข้อผิดพลาดชื่อไม่ตรงกัน เช่น NET::ERR_CERT_COMMON_NAME_INVALID และจะไม่ส่งคำขอใดๆ ออกไปเลย เนื่องจากเซิร์ฟเวอร์ได้ส่งใบรับรองของค่าเริ่มต้น (default server) ซึ่งไม่ครอบคลุมชื่อโฮสต์ที่ร้องขอ

สำหรับเว็บไซต์สาธารณะ ควรใช้ใบรับรองจริงและตั้งค่าให้ต่ออายุอัตโนมัติ Certbot กับ Let's Encrypt บน nginx จะเขียน path ของใบรับรองลงใน server block และติดตั้งตัวตั้งเวลาต่ออายุให้คุณโดยอัตโนมัติ สำหรับชื่อโฮสต์ที่หน่วยงานสาธารณะไม่สามารถตรวจสอบได้ เช่น ชื่อภายในเครือข่ายหรือ IP address ภายในเครือข่ายของคุณเอง ใบรับรองที่ลงนามเอง (self-signed certificate) บน Ubuntu เป็นทางเลือกที่ตรงไปตรงมา ตราบใดที่คุณยอมรับว่าต้องตั้งค่าให้ไคลเอนต์ทุกเครื่องเชื่อถือใบรับรองนั้น

เมื่อ TLS ทำงานได้แล้ว ให้ส่งต่อการเชื่อมต่อทั้งหมดจากพอร์ต 80 ไปยังพอร์ต 443:

server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

ให้เพิ่ม Strict-Transport-Security ก็ต่อเมื่อคุณมั่นใจแล้วเท่านั้น header add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always; จะสั่งให้เบราว์เซอร์ปฏิเสธการเชื่อมต่อ HTTP แบบปกติสำหรับชื่อโฮสต์นั้นเป็นเวลา 2 ปี และเบราว์เซอร์จะจดจำคำสั่งนี้ไว้ในแคชของตนเอง ซึ่งหมายความว่าการลบ header นี้ออกในภายหลังจะไม่สามารถยกเลิกผลลัพธ์ดังกล่าวได้ ให้เริ่มต้นด้วย max-age เพียงไม่กี่ชั่วโมง ตรวจสอบให้แน่ใจว่าทุก subdomain ใช้งาน HTTPS ได้จริง แล้วจึงค่อยเพิ่มระยะเวลาขึ้น

FAQ

HTTP และ HTTPS แตกต่างกันอย่างไร?

HTTPS คือ HTTP ที่ส่งผ่านเซสชัน TLS (transport layer security) วิธีการและรหัสสถานะ (status code) จะเหมือนกันทุกประการ สิ่งที่เปลี่ยนไปคือข้อมูลจะถูกเข้ารหัสระหว่างไคลเอนต์กับจุดที่ทำ TLS termination และพอร์ตเริ่มต้นจะเปลี่ยนจาก 80 เป็น 443 เนื่องจาก TLS handshake จะเสร็จสิ้นก่อนที่ไบต์แรกของ HTTP จะถูกส่ง ความผิดพลาดของใบรับรองจึงไม่ทำให้เกิดรหัสสถานะ นี่คือเหตุผลที่คำเตือนใบรับรองของเบราว์เซอร์แสดงชื่อข้อผิดพลาด เช่น NET::ERR_CERT_COMMON_NAME_INVALID แทนที่จะเป็นตัวเลขอย่าง 403

ทำไมเว็บไซต์ของฉันถึงแสดงข้อผิดพลาด 502 Bad Gateway?

502 จาก nginx หมายความว่า nginx ไม่สามารถรับการตอบสนองที่ใช้งานได้จาก upstream ที่ทำหน้าที่ proxy ดังนั้นคำขอของผู้เข้าชมจึงถูกต้อง แต่มีบางอย่างที่อยู่หลัง nginx ทำงานผิดปกติ ให้อ่าน /var/log/nginx/error.log หากพบ connect() failed (111: Connection refused) while connecting to upstream หมายความว่าไม่มีบริการใดกำลังฟังอยู่ที่แอดเดรสและพอร์ตใน proxy_pass ให้ตรวจสอบว่าแอปพลิเคชันกำลังทำงานและผูกอยู่กับตำแหน่งที่คุณคาดหวังไว้ ส่วน no live upstreams while connecting to upstream หมายความว่าเซิร์ฟเวอร์ทุกตัวในบล็อก upstream ถูกทำเครื่องหมายว่าใช้งานไม่ได้หลังจากล้มเหลวซ้ำๆ ให้เปรียบเทียบกับ 504 Gateway Timeout ซึ่งหมายความว่า nginx หมดเวลา (timeout) ในการรอ upstream ไม่ว่าจะเป็นการรอให้การเชื่อมต่อเสร็จสิ้นภายใน proxy_connect_timeout หรือรอการตอบสนองภายใน proxy_read_timeout

ทำไม access log ของฉันถึงแสดง IP address เดียวกันสำหรับผู้เข้าชมทุกคน?

เพราะ $remote_addr จะบันทึกแอดเดรสที่เปิดการเชื่อมต่อ TCP ซึ่งหากอยู่หลัง reverse proxy หรือ content delivery network แอดเดรสนั้นจะเป็นของ proxy แทน แอดเดรสของผู้เข้าชมจะอยู่ใน header X-Forwarded-For ให้ตั้งค่า proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; บน proxy จากนั้นบน nginx ที่เป็นผู้รับ ให้ตั้งค่า set_real_ip_from เป็นช่วงแอดเดรสของ proxy และตั้งค่า real_ip_header X-Forwarded-For; ให้ระบุเฉพาะช่วงแอดเดรสที่คุณควบคุมเท่านั้น เพราะ header ดังกล่าวเป็นข้อความที่ไคลเอนต์ใดๆ ก็สามารถส่งมาได้ การเชื่อถือ header นี้จากอินเทอร์เน็ตทั้งหมดจะทำให้ผู้เข้าชมสามารถเลือกแอดเดรสที่คุณบันทึกและแอดเดรสที่คุณใช้จำกัดอัตราการเข้าถึง (rate limit) ได้

ฉันจำเป็นต้องเปิดใช้งาน HTTP/2 หรือ HTTP/3 หรือไม่?

HTTP/2 ควรเปิดใช้งานเพราะเป็นเพียง directive เดียวบนไซต์ที่มี TLS อยู่แล้ว และช่วยลบข้อจำกัดจำนวนคำขอต่อการเชื่อมต่อ ซึ่งช่วยแก้ปัญหาหน้าเว็บที่มีไฟล์ขนาดเล็กจำนวนมากโหลดช้า ส่วน HTTP/3 ให้ผลลัพธ์ที่น้อยกว่าและไม่แน่นอนกว่า อีกทั้งยังต้องเปิดพอร์ต UDP ซึ่งปกติคือ 443 และต้องใช้ proxy ที่สร้างขึ้นพร้อมรองรับ QUIC โปรดจำไว้ว่าเบราว์เซอร์มักจะเปลี่ยนไปใช้ HTTP/3 หลังจากเห็น header Alt-Svc ในการตอบสนองก่อนหน้า หรือมีระเบียน HTTPS DNS ที่ระบุ h3 ดังนั้นหากไม่มีสิ่งเหล่านี้ การตั้งค่าบรรทัด listen ของคุณก็จะไม่ส่งผลใดๆ ให้เพิ่ม $server_protocol ลงในรูปแบบ log ของคุณและวัดผลสิ่งที่ผู้เข้าชมใช้งานจริงก่อนที่จะเสียเวลาดำเนินการ

ข้อผิดพลาด 403 Forbidden หมายความว่าอย่างไรในเมื่อไฟล์มีอยู่จริง?

บนไซต์แบบ static ข้อผิดพลาด 403 มักเกิดจากสิทธิ์ในระบบไฟล์ (filesystem permission) มากกว่ากฎของ HTTP หากพบ open() ... failed (13: Permission denied) ใน /var/log/nginx/error.log หมายความว่าผู้ใช้ที่รัน nginx ไม่สามารถอ่านไฟล์ได้ ซึ่งส่วนใหญ่มักเกิดจากไดเรกทอรีแม่ขาดสิทธิ์ execute สำหรับผู้อื่น ไม่ใช่เพราะโหมดของไฟล์นั้นผิด ส่วน directory index of ... is forbidden หมายความว่าคำขอชี้ไปยังไดเรกทอรีที่ไม่มีไฟล์ index ในขณะที่ autoindex ถูกปิดอยู่ นอกจากนี้ กฎ deny ที่ระบุไว้อย่างชัดเจนในบล็อก location ที่ตรงกันก็ส่งผลให้เกิด 403 ได้เช่นกัน ดังนั้นให้อ่านบล็อกนั้นหาก log ข้อผิดพลาดไม่ได้ระบุรายละเอียดใดๆ

บทความนี้มีประโยชน์หรือไม่