บทความ

บทนำ: สิ่งที่คุณจะได้รับจากคู่มือนี้

ถ้าคุณเคยสร้างบอทใน Telegram อย่างน้อยหนึ่งครั้ง คุณคงรู้ปัญหาที่น่ารำคาญอย่างหนึ่ง นั่นคือ ตัวบอทเขียนเสร็จภายในคืนเดียว แต่การทำให้มันทำงานเสถียรกลับกลายเป็นอีกโปรเจกต์หนึ่ง ข้อความมาช้า อัปเดตหาย เซิร์ฟเวอร์จู่ๆ ก็ได้รับข้อผิดพลาด 429 และ webhook ก็หยุดถูกเรียกโดยไม่มีคำอธิบาย เพิ่มพร็อกซีที่ทุกคำขอต้องผ่านเข้าไปอีก จำนวนจุดที่ล้มเหลวก็เพิ่มขึ้นเป็นสองเท่า

คู่มือทีละขั้นตอนนี้แก้ปัญหาเหล่านี้โดยตรง คุณจะได้เรียนรู้การทำงานกับ Telegram Bot API ผ่านพร็อกซีเซิร์ฟเวอร์ เพื่อให้บอทไม่ล่ม ไม่ทำข้อความหาย และตอบสนองต่อลิมิตอย่างถูกต้อง เราจะไม่พูดถึงโปรโตคอล MTProto และจะไม่สร้างระบบมอนิเตอร์พร็อกซี หัวข้อของเราเจาะจงและใช้งานได้จริงกว่า: คำขอ HTTP ไปยัง api.telegram.org ผ่านพร็อกซี, สองวิธีรับอัปเดต และการตอบสนองต่อข้อจำกัดอย่างถูกต้อง

สิ่งที่คุณจะได้รับในที่สุด

  • บอทที่ทำงานได้จริง ส่งคำขอไปยัง Telegram Bot API ผ่านพร็อกซีของคุณ (HTTP หรือ SOCKS5)
  • Long Polling ที่ตั้งค่าแล้ว ไม่ขาดตอนเพราะ timeout และไม่ส่งข้อความซ้ำ
  • Webhook ที่มี HTTPS และ Secret Token รับอัปเดตบนเซิร์ฟเวอร์ของคุณ
  • ตัวห่อคำขอที่พร้อมใช้ ซึ่งรอเวลาที่เหมาะสมเมื่อเจอข้อผิดพลาด 429 แล้วส่งซ้ำ
  • ความเข้าใจว่าจะเลือกรูปแบบไหนสำหรับโปรเจกต์ของคุณ: polling หรือ webhook

คู่มือนี้สำหรับใคร

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

สิ่งที่ควรรู้ก่อนเริ่ม

เราอธิบายทุกขั้นตอนตั้งแต่ศูนย์ แต่ทักษะพื้นฐานเล็กน้อยจะทำให้ชีวิตง่ายขึ้นมาก การเปิดเทอร์มินัลหรือ command line การคัดลอกคำสั่ง และการรันสคริปต์ Python ถือเป็นประโยชน์ การรู้ว่า HTTP request และ JSON คืออะไรก็เช่นกัน แต่เราจะเตือนความจำด้วยคำง่ายๆ หัวข้อขั้นสูงถูกแยกไปไว้ในส่วนต่างหาก ผู้เริ่มต้นข้ามได้โดยไม่กระทบผลลัพธ์

ต้องใช้เวลานานแค่ไหน

การเตรียมและสร้างบอทใช้เวลาประมาณ 20 นาที ตั้งค่าพร็อกซีและคำขอแรกที่สำเร็จอีก 20-30 นาที Long Polling คุณจะรันได้ภายในครึ่งชั่วโมง Webhook ต้องใช้เวลา 40-60 นาที เพราะต้องมีใบรับรอง HTTPS การจัดการข้อผิดพลาด 429 เพิ่มอีก 20 นาที รวมแล้วสองถึงสามชั่วโมงทำงานสบายๆ พร้อมตรวจสอบในแต่ละขั้น

การเตรียมการเบื้องต้น: เครื่องมือและการเข้าถึง

ก่อนเขียนโค้ดบรรทัดแรก มารวบรวมทุกอย่างที่จำเป็นกันก่อน คุณจะได้ไม่ต้องหยุดกลางทางเพื่อหาว่ารหัสผ่านพร็อกซีอยู่ไหนหรือติดตั้งไลบรารีอย่างไร

เครื่องมือและการเข้าถึงที่จำเป็น

  1. บัญชี Telegram ที่ผูกเบอร์โทรแล้ว คุณจะใช้มันสร้างบอทผ่านบอททางการชื่อ BotFather
  2. การเข้าถึงพร็อกซี: ที่อยู่เซิร์ฟเวอร์ พอร์ต ล็อกอิน และรหัสผ่าน ในหน้าจัดการของ mobileproxy.space ข้อมูลเหล่านี้แสดงในบัตรพร็อกซีที่ซื้อ โดยปกติจะมีสองพอร์ต: หนึ่งสำหรับ HTTP อีกหนึ่งสำหรับ SOCKS5 จดทั้งคู่ไว้
  3. คอมพิวเตอร์หรือเซิร์ฟเวอร์ ที่ติดตั้ง Python 3.10 หรือใหม่กว่า สำหรับ webhook ต้องใช้เซิร์ฟเวอร์ที่มี IP สาธารณะและโดเมน บนคอมพิวเตอร์ที่บ้าน webhook จะไม่ทำงาน
  4. ยูทิลิตี้ curl ใน Windows 10 และ 11, macOS และ Linux มีมาให้แล้ว ตรวจสอบด้วยคำสั่ง curl --version
  5. โปรแกรมแก้ไขข้อความ: VS Code, Notepad++ หรืออื่นๆ ที่เขียนโค้ดได้สะดวก

ข้อกำหนดระบบ

สำหรับ polling แทบไม่มีข้อกำหนด: เครื่องใดก็ได้ที่ต่ออินเทอร์เน็ต รวมถึงโน้ตบุ๊ก บอทใช้หน่วยความจำไม่กี่สิบเมกะไบต์ สำหรับ webhook ต้องใช้ VPS สเปกขั้นต่ำ: 1 คอร์, RAM 1 GB, Ubuntu 22.04 หรือ 24.04 จำเป็นต้องมีโดเมนชี้ไปที่ IP ของเซิร์ฟเวอร์นี้ และเปิดพอร์ต 443 ในไฟร์วอลล์

สิ่งที่ต้องติดตั้ง

  1. เปิดเทอร์มินัล
  2. ตรวจสอบ Python ด้วยคำสั่ง python3 --version บน Windows คำสั่งอาจเป็น python --version
  3. สร้างโฟลเดอร์โปรเจกต์: mkdir tgbot-proxy แล้วเข้าไป cd tgbot-proxy
  4. สร้าง virtual environment: python3 -m venv venv เปิดใช้งาน: บน Linux และ macOS source venv/bin/activate บน Windows venv\Scripts\activate
  5. ติดตั้งไลบรารี: pip install requests[socks] flask แพ็กเกจ requests รับผิดชอบคำขอไปยัง Telegram Bot API ส่วนเสริม socks จำเป็นสำหรับพร็อกซีแบบ SOCKS5 และ Flask จะรับ webhook

การสำรองข้อมูลและความปลอดภัยของข้อมูล

ให้ถือว่าโทเคนบอทเทียบเท่ารหัสผ่านแอปธนาคาร ใครได้ไปก็สามารถส่งข้อความในนามบอทถึงลูกค้าคุณได้ สร้างไฟล์ .env เก็บโทเคนและข้อมูลพร็อกซี และอย่าส่งมันไปยังที่เก็บโค้ดสาธารณะเด็ดขาด ถ้าบอททำงานอยู่แล้วและคุณกำลังย้ายมันมาที่พร็อกซี ให้บันทึกการตั้งค่าปัจจุบัน สำรองฐานข้อมูลถ้ามี และจดผลลัพธ์ของเมธอด getWebhookInfo ไว้ แล้วการย้อนกลับจะใช้เวลาแค่สองนาที

เคล็ดลับ: สร้างบอททดสอบแยกต่างหากสำหรับการทดลอง ทุกขั้นตอนในคู่มือนี้ให้ทดลองกับมันก่อน แล้วค่อยย้ายเฉพาะการตั้งค่าที่ผ่านการตรวจสอบไปยังบอทจริง คุณจะไม่ทำลายการสื่อสารกับลูกค้าจริง

แนวคิดพื้นฐาน: Telegram Bot API ทำงานอย่างไร

มาทำความเข้าใจคำศัพท์สำคัญด้วยคำง่ายๆ ถ้าไม่มีมัน ขั้นตอนต่อไปจะดูเหมือนเวทมนตร์ แต่ถ้ามี มันจะสมเหตุสมผลและคาดเดาได้

Telegram Bot API

มันคืออินเทอร์เฟซ HTTP ธรรมดา โค้ดของคุณส่งคำขอไปยังที่อยู่แบบ https://api.telegram.org/bot<TOKEN>/<method> แล้วเซิร์ฟเวอร์ Telegram ตอบกลับเป็นอ็อบเจกต์ JSON ตัวอย่างเช่น เมธอด getMe คืนข้อมูลบอท ส่วน sendMessage ส่งข้อความไปยังแชท ไม่ต้องใช้ไลบรารีพิเศษ แค่ curl หรือ requests ก็พอ นี่คือเหตุผลที่ Telegram Bot API ผ่านพร็อกซีได้ง่าย: มันคือทราฟฟิกเดียวกับเว็บไซต์ใดๆ ผ่าน HTTPS

อัปเดต (updates)

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

Long Polling

บอทของคุณถาม Telegram เองว่ามีอัปเดตใหม่ไหม? ทำผ่านเมธอด getUpdates คำว่า "long" หมายความว่าเซิร์ฟเวอร์ไม่ตอบกลับทันทีด้วยลิสต์ว่าง แต่จะเปิดการเชื่อมต่อไว้จนถึง timeout ที่กำหนด ปกติ 30-60 วินาที และตอบทันทีเมื่อมีเหตุการณ์ ช่วยประหยัดคำขอและให้การตอบสนองเกือบทันที Polling ไม่ต้องมีที่อยู่สาธารณะ ทำงานหลังเราเตอร์และผ่านพร็อกซีใดก็ได้ เหมาะสำหรับเริ่มต้นและบอทที่มีโหลดน้อย

Webhook

วิธีกลับกัน คุณแจ้งที่อยู่เซิร์ฟเวอร์ของคุณให้ Telegram ผ่านเมธอด setWebhook แล้ว Telegram จะส่งทุกอัปเดตเป็น POST request มาที่ที่อยู่นั้นเอง คุณไม่ต้องคอยถาม ข้อกำหนด: โดเมนสาธารณะ ใบรับรอง HTTPS และพอร์ต 443, 80, 88 หรือ 8443 หนึ่งในนั้น Webhook ขยายได้ดีกว่าและไม่เปลืองทรัพยากรในการรอ

สิ่งสำคัญที่ต้องเข้าใจ: พร็อกซีมีผลกับคำขอขาออกของบอทไปยัง Telegram เท่านั้น คำขอขาเข้าของ webhook มาถึงเซิร์ฟเวอร์คุณโดยตรง พร็อกซีไม่เกี่ยวข้องในเส้นทางนี้ ดังนั้นวลี "webhook ผ่านพร็อกซี" ในทางปฏิบัติหมายถึง: บอทตอบและเรียกเมธอด API ผ่านพร็อกซี แต่รับอัปเดตที่ที่อยู่สาธารณะของตัวเอง

ข้อผิดพลาด 429 Too Many Requests

Telegram จำกัดความถี่ของคำขอ แนวทางปี 2026: ไม่เกินหนึ่งข้อความต่อวินาทีในหนึ่งแชท ไม่เกิน 20 ข้อความต่อนาทีในหนึ่งกลุ่ม และประมาณ 30 ข้อความต่อวินาทีรวมทั้งบอท เมื่อเกิน เซิร์ฟเวอร์จะคืนสถานะ HTTP 429 และในเนื้อหาคำตอบมีฟิลด์ parameters.retry_after บอกจำนวนวินาทีที่ต้องรอ ห้ามเพิกเฉย เพราะการลองซ้ำโดยไม่หยุดจะเพิ่มเวลาบล็อก

ทำไมต้องใช้พร็อกซีกับบอท

เหตุผลเป็นเรื่องปฏิบัติล้วนๆ อย่างแรก IP ขาออกที่คงที่และคาดเดาได้: สะดวกเมื่อมีเซิร์ฟเวอร์หลายตัวแต่ต้องการที่อยู่ภายนอกเดียว อย่างที่สอง แยกทราฟฟิกตามโปรเจกต์: ลูกค้าแต่ละรายหรือแคมเปญแต่ละอันมีช่องทางของตัวเอง อย่างที่สาม นโยบายองค์กรที่บังคับให้การเชื่อมต่อภายนอกทั้งหมดผ่านเกตเวย์ มือถือพร็อกซีมีคุณค่าตรงความเสถียรและความสามารถควบคุมการเปลี่ยน IP ตามตารางหรือผ่านลิงก์

ขั้นตอนที่ 1: สร้างบอทและรับโทเคน

เป้าหมาย: ได้โทเคนเข้าถึง Telegram Bot API และยืนยันว่าบอทมีอยู่จริง

  1. เปิด Telegram บนมือถือหรือคอมพิวเตอร์
  2. ในช่องค้นหา พิมพ์ BotFather เลือกบอทที่มีเครื่องหมายถูกสีฟ้า บอทปลอมจะไม่มี
  3. กดปุ่ม Start หรือส่งคำสั่ง /start คุณจะเห็นรายการคำสั่งที่มีให้
  4. ส่งคำสั่ง /newbot
  5. BotFather จะถามชื่อบอท พิมพ์ชื่อที่แสดง เช่น Proxy Test Bot มีช่องว่างและตัวอักษรรัสเซียได้
  6. ต่อไปจะถาม username ต้องไม่ซ้ำ ใช้ตัวอักษรละติน และลงท้ายด้วย bot เช่น proxy_test_2026_bot ถ้าซ้ำ BotFather จะแจ้ง ให้คิดใหม่
  7. จะได้รับข้อความแสดงความยินดีพร้อมสตริงแบบ 123456789:AAExampleTokenLettersAndDigits นี่คือ โทเคน คัดลอกทั้งหมด รวมตัวเลขหน้าเครื่องหมายโคลอน
  8. สร้างไฟล์ .env ในโฟลเดอร์โปรเจกต์ แล้วเขียนบรรทัด BOT_TOKEN=โทเคนของคุณ

ระวัง: อย่าเผยแพร่โทเคนในแชท ภาพหน้าจอ หรือที่เก็บโค้ดสาธารณะเด็ดขาด ถ้าโทเคนรั่ว ให้ส่งคำสั่ง /revoke ไปยัง BotFather เลือกบอท แล้วรับโทเคนใหม่ โทเคนเก่าจะใช้ไม่ได้ทันที

คำขอแรกโดยไม่ใช้พร็อกซี

ก่อนทำให้ซับซ้อน ตรวจสอบว่าโทเคนใช้ได้ด้วยคำขอธรรมดาจากเครื่องคุณ รันในเทอร์มินัลโดยแทนที่โทเคนของคุณ:

curl https://api.telegram.org/bot123456789:AAExampleToken/getMe

คำตอบที่คาดหวัง: JSON เริ่มต้นด้วย {"ok":true,"result":{"id":123456789,"is_bot":true,... ข้างในจะเห็น username ของบอทที่เพิ่งตั้ง

ตรวจสอบ: ในคำตอบมี "ok":true และ username ถูกต้อง ถ้าได้ "error_code":401 แทน แสดงว่าคัดลอกโทเคนผิด ตรวจว่าตัวอักษรหัวท้ายหายไปหรือไม่

ปัญหาที่อาจเกิดขึ้น

  • Username ซ้ำ เพิ่มตัวเลขหรือตัวย่อโปรเจกต์ สิ่งสำคัญคือลงท้ายด้วย bot
  • BotFather ไม่ตอบ ตรวจว่าคุณเปิดบอทที่มีเครื่องหมายถูก ไม่ใช่บอทชื่อคล้ายกัน
  • ข้อผิดพลาด 404 Not Found ในที่อยู่ขาดคำว่า bot หน้าโทเคน รูปแบบต้องเป็น /bot<TOKEN>/method อย่างเคร่งครัด

ขั้นตอนที่ 2: เชื่อมต่อพร็อกซีและตรวจสอบการเข้าถึง API

เป้าหมาย: ทำให้คำขอไปยัง Telegram Bot API ผ่านพร็อกซีของคุณ และยืนยันด้วยข้อเท็จจริง ไม่ใช่แค่คำพูด

ทำความเข้าใจรูปแบบที่อยู่พร็อกซี

พร็อกซีอธิบายด้วยสตริงเดียว: protocol://login:password@host:port นำข้อมูลจากหน้าจัดการมา สมมติคุณได้ host proxy-host พอร์ต HTTP 8080 พอร์ต SOCKS5 1080 ล็อกอิน user และรหัสผ่าน pass แล้วสตริงจะเป็น:

  • HTTP proxy: http://user:pass@proxy-host:8080
  • SOCKS5 proxy: socks5h://user:pass@proxy-host:1080

สังเกตตัว h ใน socks5h มันหมายความว่าโดเมน api.telegram.org จะถูก resolve ที่ฝั่งพร็อกซี ไม่ใช่บนเครื่องคุณ นี่คือวิธีที่ถูกต้องสำหรับมือถือพร็อกซี: คำขอ DNS และทราฟฟิกไปเส้นทางเดียวกัน ถ้าไม่มี h เมื่อ DNS ท้องถิ่นมีปัญหา คำขอจะล้มเหลวแม้พร็อกซีจะปกติ

ถ้ารหัสผ่านมีอักขระ @, : หรือ / ต้อง encode: @ เป็น %40 เครื่องหมายโคลอนเป็น %3A เครื่องหมายทับเป็น %2F ไม่เช่นนั้นสตริงจะถูกแยกผิด

ตรวจสอบด้วย curl

  1. ก่อนอื่นดูว่าเซอร์วิสภายนอกเห็น IP อะไรผ่านพร็อกซี รัน: curl -x http://user:pass@proxy-host:8080 https://api.ipify.org จะได้ที่อยู่ IP มันต้องต่างจากที่อยู่บ้านหรือเซิร์ฟเวอร์ของคุณ
  2. ตอนนี้คำขอเดียวกันไปยัง Telegram Bot API: curl -x http://user:pass@proxy-host:8080 https://api.telegram.org/bot123456789:AAExampleToken/getMe
  3. สำหรับ SOCKS5 เปลี่ยนพารามิเตอร์: curl -x socks5h://user:pass@proxy-host:1080 https://api.telegram.org/bot123456789:AAExampleToken/getMe
  4. วัดเวลาตอบสนอง: เพิ่มท้ายคำสั่ง -w " เวลา: %{time_total}" ค่าถึง 1-2 วินาทีสำหรับมือถือพร็อกซีถือว่าปกติ

ตรวจสอบ: ทั้งสองคำขอคืน "ok":true และ IP จากคำสั่งแรกต่างจากของคุณ แสดงว่าเส้นทางผ่านพร็อกซีทำงานและ Telegram Bot API ตอบผ่านมัน

ตั้งค่าพร็อกซีใน Python

สร้างไฟล์ config.py เนื้อหาดังนี้ แทนค่าด้วยของคุณ:

import os
TOKEN = os.getenv('BOT_TOKEN', '123456789:AAExampleTokenReplaceMe')
PROXY = os.getenv('BOT_PROXY', 'http://user:pass@proxy-host:8080')
PROXIES = {'http': PROXY, 'https': PROXY}
BASE = f'https://api.telegram.org/bot{TOKEN}'

คีย์ https ในดิกชันนารีจำเป็น เพราะ Telegram Bot API ทำงานผ่าน HTTPS เท่านั้น ข้อผิดพลาดที่พบบ่อยของผู้เริ่มต้นคือระบุแค่ http แล้วสงสัยว่าทำไมทราฟฟิกวิ่งตรง

ตอนนี้สคริปต์ทดสอบ check.py:

import requests
from config import PROXIES, BASE
ip = requests.get('https://api.ipify.org', proxies=PROXIES, timeout=15).text
print('IP ขาออก:', ip)
me = requests.get(f'{BASE}/getMe', proxies=PROXIES, timeout=15).json()
print('บอท:', me['result']['username'])

รัน: python check.py บนหน้าจอจะแสดง IP พร็อกซีและ username บอท

เคล็ดลับ: ถ้าไม่อยากแก้โค้ดไลบรารีที่ใช้อยู่ ให้ตั้งตัวแปรสภาพแวดล้อม HTTPS_PROXY=http://user:pass@proxy-host:8080 ไลบรารี requests และไคลเอนต์ HTTP ส่วนใหญ่จะรับมันอัตโนมัติ นี่เป็นวิธีที่สะดวกในการย้ายบอทที่มีอยู่มาที่พร็อกซีโดยไม่ต้องแก้โค้ด

การตั้งค่าในเฟรมเวิร์กยอดนิยม

  • aiogram 3.x: สร้าง session AiohttpSession(proxy='http://user:pass@proxy-host:8080') แล้วส่งตอนสร้างอ็อบเจกต์ Bot(token=TOKEN, session=session) สำหรับ SOCKS5 ต้องใช้แพ็กเกจ aiohttp-socks
  • python-telegram-bot 21.x: ใช้ HTTPXRequest(proxy='http://user:pass@proxy-host:8080') แล้วส่งใน ApplicationBuilder().token(TOKEN).request(request)
  • Node.js: แพ็กเกจ https-proxy-agent หรือ socks-proxy-agent สร้าง agent ที่ส่งในออปชันของไคลเอนต์ HTTP หรือคอนสตรัคเตอร์ของไลบรารีบอท

ปัญหาที่อาจเกิดขึ้น

  • 407 Proxy Authentication Required ล็อกอินหรือรหัสผ่านผิด หรือไม่ได้ encode อักขระพิเศษ ตรวจข้อมูลในหน้าจัดการ
  • Connection refused พอร์ตระบุผิด หรือสลับพอร์ต HTTP กับ SOCKS5 ลองพอร์ตที่สอง
  • คำขอวิ่งตรง ในดิกชันนารีไม่มีคีย์ https หรือตัวแปรสภาพแวดล้อมตั้งในหน้าต่างเทอร์มินัลอื่น
  • ข้อผิดพลาด SSL อย่าปิดการตรวจสอบใบรับรอง อัปเดตแพ็กเกจ certifi ด้วยคำสั่ง pip install -U certifi และตรวจเวลาระบบ

ขั้นตอนที่ 3: รัน Long Polling ผ่านพร็อกซี

เป้าหมาย: ได้บอทที่ทำงาน ดึงอัปเดตผ่านพร็อกซีด้วยเมธอด getUpdates และตอบข้อความโดยไม่หายและไม่ซ้ำ

วิธีสร้างลูป polling อย่างถูกต้อง

ตรรกะง่าย แต่รายละเอียดสำคัญ คุณเรียก getUpdates ด้วยพารามิเตอร์ offset เท่ากับ update_id ของอัปเดตล่าสุดที่ประมวลผลแล้วบวกหนึ่ง Telegram จึงเข้าใจว่าอัปเดตก่อนหน้าถูกรับแล้วและลบออกจากฝั่งมัน ถ้าลืม offset ข้อความเดียวกันจะมาซ้ำแล้วซ้ำอีก และบอทจะตอบหลายครั้ง

พารามิเตอร์ timeout กำหนดว่าเซิร์ฟเวอร์เปิดการเชื่อมต่อรอเหตุการณ์กี่วินาที ตรงนี้เริ่มมีลักษณะเฉพาะของพร็อกซี พร็อกซีทุกตัวมี timeout ของการเชื่อมต่อที่ไม่ใช้งาน ของมือถือพร็อกซีมักอยู่ราว 60-120 วินาที ถ้า timeout ของ polling มากกว่า พร็อกซีจะตัดการเชื่อมต่อก่อนที่ Telegram จะตอบ และคุณจะได้ข้อผิดพลาดแทนอัปเดต ค่าที่ปลอดภัยคือ timeout=50 เมื่อ timeout ของไคลเอนต์ HTTP 60 วินาที timeout ของไคลเอนต์ต้องมากกว่า timeout ของ polling เสมอ ไม่เช่นนั้นไคลเอนต์จะหลุดก่อน

เขียนบอท

  1. สร้างไฟล์ polling.py
  2. คัดลอกโค้ดด้านล่าง
  3. รันด้วยคำสั่ง python polling.py
  4. ส่งข้อความใดก็ได้ให้บอทใน Telegram
import time, requests
from config import PROXIES, BASE
offset = 0
print('เริ่ม polling ผ่านพร็อกซี')
while True:
try:
r = requests.get(f'{BASE}/getUpdates', params={'offset': offset, 'timeout': 50}, proxies=PROXIES, timeout=60)
data = r.json()
except requests.RequestException as e:
print('ข้อผิดพลาดเครือข่าย:', e)
time.sleep(3)
continue
if not data.get('ok'):
print('ข้อผิดพลาด API:', data)
time.sleep(3)
continue
for upd in data['result']:
offset = upd['update_id'] + 1
msg = upd.get('message')
if msg and 'text' in msg:
requests.post(f'{BASE}/sendMessage', json={'chat_id': msg['chat']['id'], 'text': 'รับทราบ: ' + msg['text']}, proxies=PROXIES, timeout=15)

มาดูว่าเกิดอะไรขึ้น ลูปชั้นนอกไม่สิ้นสุดเอง บล็อก try จับข้อผิดพลาดเครือข่าย: พร็อกซีขาด timeout การเปลี่ยน IP เมื่อเกิดข้อผิดพลาด สคริปต์รอสามวินาทีแล้วลองใหม่ ไม่ล้ม การตรวจ data.get('ok') จับข้อผิดพลาดระดับ API ลูปชั้นในประมวลผลแต่ละอัปเดตและเลื่อน offset ทันที

ตรวจสอบ: ในคอนโซลมีบรรทัดแจ้งว่าเริ่มทำงาน และหลังส่งข้อความบอทตอบ "รับทราบ: ข้อความของคุณ" ส่งสามข้อความติดกัน บอทต้องตอบหนึ่งครั้งต่อหนึ่งข้อความเท่านั้น หยุดสคริปต์ด้วย Ctrl+C ส่งข้อความ แล้วเริ่มใหม่: บอทจะตอบข้อความที่พลาดไป เพราะ Telegram เก็บอัปเดตที่ยังไม่ประมวลผลได้ถึง 24 ชั่วโมง

ลักษณะพิเศษของมือถือพร็อกซีเมื่อใช้ polling

มือถือพร็อกซีเปลี่ยน IP ได้: ตามตัวจับเวลาหรือผ่านลิงก์พิเศษจากหน้าจัดการ ในจังหวะเปลี่ยน IP การเชื่อมต่อ polling ที่เปิดอยู่จะขาด นี่ไม่ใช่ข้อผิดพลาดของโค้ดคุณ แต่เป็นพฤติกรรมปกติของเครือข่าย ลูปของเราพร้อมรับแล้ว: จะจับ exception รอ แล้วทำต่อจาก offset เดิม ไม่มีอัปเดตใดหายไป

อย่างไรก็ตาม การหมุนเวียนบ่อยสร้างเสียงรบกวนในล็อกและความหน่วงเล็กน้อย คำแนะนำ: สำหรับบอทที่ใช้ polling ตั้งช่วงหมุนเวียนในหน้าจัดการตั้งแต่ 10 นาทีขึ้นไป หรือปิดการเปลี่ยนอัตโนมัติและเปลี่ยน IP ผ่านลิงก์เฉพาะเมื่อจำเป็นจริงๆ บอทไม่ใช่ตัว scrape ไม่ต้องมีที่อยู่ใหม่ทุกนาที

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

ปัญหาที่อาจเกิดขึ้น

  • ข้อผิดพลาด 409 Conflict พบบ่อยที่สุด บอทตั้ง webhook อยู่ และ polling กับ webhook ทำงานพร้อมกันไม่ได้ รัน curl -x พร็อกซีคุณ https://api.telegram.org/botTOKEN/deleteWebhook แล้วเริ่มสคริปต์ใหม่ เหตุผลที่สอง: มีสคริปต์สองชุดรันอยู่ ปิดอันที่เกิน
  • บอทตอบทุกข้อความสองครั้ง Offset ไม่เลื่อน หรือมีบอทสองชุดรันอยู่
  • Read timed out บ่อยๆ Timeout ของ polling มากกว่า timeout ของพร็อกซี ลด timeout เหลือ 30-40 วินาที
  • ตอบช้า 5-10 วินาที ตรวจเวลาตอบสนองพร็อกซีด้วย curl ถ้าช่องทางช้าเอง เปลี่ยนจุดออกหรือแพ็กเกจ

ขั้นตอนที่ 4: ตั้งค่า Webhook ด้วย HTTPS และ Secret Token

เป้าหมาย: Telegram ส่งอัปเดตมาที่เซิร์ฟเวอร์คุณเอง ส่วนบอทตอบผ่านพร็อกซี ขั้นนี้ต้องใช้ VPS พร้อมโดเมน ถ้าตอนนี้คุณมีแค่ polling และพอใจแล้ว ข้ามไปขั้นตอนที่ 5 แล้วค่อยกลับมาก็ได้

เตรียมเซิร์ฟเวอร์และโดเมน

  1. เช่า VPS ที่ใช้ Ubuntu จด IP สาธารณะ
  2. ในแผงจัดการโดเมน สร้าง A record เช่น bot.example.com ชี้ไปที่ IP เซิร์ฟเวอร์ รอ DNS อัปเดต ปกติ 5-30 นาที ตรวจด้วยคำสั่ง nslookup bot.example.com
  3. เชื่อมต่อเซิร์ฟเวอร์ผ่าน SSH และอัปเดตแพ็กเกจ: sudo apt update
  4. ติดตั้ง nginx และ certbot: sudo apt install nginx certbot python3-certbot-nginx
  5. เปิดพอร์ต 80 และ 443: sudo ufw allow 80, sudo ufw allow 443
  6. รับใบรับรองฟรี: sudo certbot --nginx -d bot.example.com ทำตามคำแนะนำ ใส่อีเมล ยอมรับเงื่อนไข อีกหนึ่งนาทีจะได้ใบรับรอง

Telegram รับ webhook ผ่าน HTTPS ที่มีใบรับรองถูกต้องจากหน่วยงานที่เชื่อถือได้เท่านั้น ใบรับรองจาก certbot ตรงตามข้อกำหนด ใบรับรองที่ออกเองก็ได้ แต่ต้องอัปโหลดส่วนสาธารณะผ่านพารามิเตอร์ certificate ใน setWebhook ซึ่งยุ่งยากกว่า สำหรับผู้เริ่มต้น certbot ง่ายกว่า

ตั้งค่า nginx เป็นจุดเข้า

Nginx จะรับคำขอ HTTPS จาก Telegram และส่งต่อไปยังแอป Flask ที่ฟังพอร์ตท้องถิ่น 8080 เปิดไฟล์คอนฟิกที่ certbot สร้างด้วยคำสั่ง sudo nano /etc/nginx/sites-available/default แล้วเพิ่ม location นี้ในบล็อก server ที่ใช้พอร์ต 443:

location /tg/webhook {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_read_timeout 30s;
}

บันทึกไฟล์ ตรวจไวยากรณ์ด้วย sudo nginx -t แล้วโหลดใหม่ sudo systemctl reload nginx

เคล็ดลับ: ทำเส้นทาง webhook ให้เดายาก เช่น /tg/webhook/k8s7d2f นี่ไม่ใช่การแทน secret token แต่เป็นชั้นเพิ่มเติม: ตัวสแกนสุ่มจะหาจุดเข้าของคุณไม่เจอ

เขียนตัวจัดการ webhook

สร้างไฟล์ webhook.py บนเซิร์ฟเวอร์ มันรับ POST จาก Telegram ตรวจส่วนหัวลับ และตอบผู้ใช้ผ่านพร็อกซี ฟังก์ชัน call เราจะเขียนในขั้นตอนถัดไป ตอนนี้ใช้ requests.post ธรรมดาพร้อม proxies ไปก่อน

import requests
from flask import Flask, request, abort
from config import PROXIES, BASE
app = Flask(__name__)
SECRET = 'MySecret123'
@app.post('/tg/webhook')
def webhook():
if request.headers.get('X-Telegram-Bot-Api-Secret-Token') != SECRET:
abort(403)
update = request.get_json(silent=True) or {}
msg = update.get('message')
if msg and 'text' in msg:
requests.post(f'{BASE}/sendMessage', json={'chat_id': msg['chat']['id'], 'text': 'ได้รับผ่าน webhook'}, proxies=PROXIES, timeout=15)
return 'ok', 200
if __name__ == '__main__':
app.run(host='127.0.0.1', port=8080)

จุดสำคัญ: ส่วนหัว X-Telegram-Bot-Api-Secret-Token Telegram เพิ่มมันในทุกคำขอถ้าคุณระบุ secret_token ตอนตั้ง webhook คำขอใดที่ไม่มีค่าถูกต้องจะถูกปฏิเสธด้วยรหัส 403 วิธีนี้ไม่มีใครแอบส่งข้อความปลอมให้บอทได้

รันแอป: python webhook.py สำหรับการทำงานถาวรค่อยทำเป็น systemd service แต่สำหรับทดสอบรันตรงๆ ก็พอ

ลงทะเบียน webhook ผ่านพร็อกซี

การเรียก setWebhook เองก็ผ่านพร็อกซี เพราะเป็นคำขอขาออกไปยัง Telegram Bot API รันบนเครื่องใดก็ได้ที่มีสิทธิ์เข้าถึงพร็อกซี:

curl -x http://user:pass@proxy-host:8080 -F "url=https://bot.example.com/tg/webhook" -F "secret_token=MySecret123" -F "max_connections=40" -F "drop_pending_updates=true" https://api.telegram.org/bot123456789:AAExampleToken/setWebhook

มาดูพารามิเตอร์ url — ที่อยู่ตัวจัดการของคุณ secret_token — สตริง 1 ถึง 256 ตัวอักษรจากตัวอักษรละติน ตัวเลข ขีดกลาง และขีดล่าง ต้องตรงกับ SECRET ในโค้ด max_connections — จำนวนคำขอพร้อมกันที่ Telegram เปิดมาหาคุณได้ 1 ถึง 100 ค่าเริ่มต้น 40 drop_pending_updates — รีเซ็ตอัปเดตที่ค้างอยู่ เพื่อไม่ให้บอทส่งคำตอบเก่าเป็นชุดตอนสลับ

คำตอบที่คาดหวัง: {"ok":true,"result":true,"description":"Webhook was set"}

วินิจฉัยผ่าน getWebhookInfo

นี่คือเครื่องมือหลักในการดีบัก webhook รัน:

curl -x http://user:pass@proxy-host:8080 https://api.telegram.org/bot123456789:AAExampleToken/getWebhookInfo

ในคำตอบดูที่ฟิลด์: url ต้องตรงกับของคุณ pending_update_count แสดงคิวอัปเดตที่ยังไม่ประมวลผล last_error_date และ last_error_message จะปรากฏถ้า Telegram ส่งอัปเดตไม่ได้ ฟิลด์ข้อผิดพลาดว่างเปล่าหลังส่งข้อความทดสอบหมายถึงสำเร็จเต็มที่

ตรวจสอบ: เขียนหาบอท บอทตอบ "ได้รับผ่าน webhook" ใน getWebhookInfo ไม่มี last_error_message และ pending_update_count เป็นศูนย์ ในล็อก Flask เห็นบรรทัด POST /tg/webhook พร้อมรหัส 200

ระวัง: ตัวจัดการ webhook ต้องตอบเร็วภายในไม่กี่วินาที ถ้าโค้ดคุณคิดนาน เช่น ทำคำขอหนักไปที่ฐานข้อมูลหรือเซอร์วิสภายนอกผ่านพร็อกซีช้า Telegram จะถือว่าส่งไม่สำเร็จและส่งซ้ำ งานหนักให้ย้ายไปงานเบื้องหลัง ส่วน webhook คืน 200 ทันที

ปัญหาที่อาจเกิดขึ้น

  • last_error_message: SSL error ใบรับรองไม่ถูกต้อง หมดอายุ หรือออกให้โดเมนอื่น ตรวจด้วย sudo certbot certificates
  • Connection timed out พอร์ต 443 ปิดในไฟร์วอลล์หรือที่โฮสต์ ตรวจ sudo ufw status และการตั้งค่าในแผง VPS
  • Wrong response from the webhook: 403 secret token ในโค้ดกับใน setWebhook ไม่ตรงกัน ตรวจตัวพิมพ์เล็กใหญ่
  • Wrong response from the webhook: 502 Flask ไม่ได้รันหรือฟังพอร์ตอื่น ตรวจ ss -tlnp | grep 8080
  • Bad webhook: port not allowed ใช้ได้แค่ 443, 80, 88 หรือ 8443

ขั้นตอนที่ 5: จัดการข้อผิดพลาด 429 และทำให้คำขอทนทาน

เป้าหมาย: เขียนฟังก์ชันเดียวสำหรับทุกการเรียก Telegram Bot API ที่รอตาม 429 เอง ส่งซ้ำเมื่อเครือข่ายและพร็อกซีล้ม และไม่ทำให้บอทล่ม

ทำไมห้ามเพิกเฉย 429

เมื่อคุณส่งข้อความหาผู้ใช้พันคน ลิมิต 30 ข้อความต่อวินาทีถึงทันที Telegram ตอบ 429 และระบุ retry_after ถ้ายังคงกระหน่ำเซิร์ฟเวอร์ ข้อความจะไม่ไป และเวลารอในคำตอบถัดไปจะเพิ่มขึ้น เมื่อทำงานผ่านพร็อกซีมีจุดสำคัญ: ลิมิตของ Telegram ผูกกับบอท ไม่ใช่ IP การเปลี่ยน IP ผ่านการหมุนเวียนไม่ช่วยหลบข้อจำกัด และไม่ควรใช้เพื่อการนั้น วิธีเดียวที่ถูกต้องคือเคารพ retry_after และควบคุมความเร็วในการส่ง

เขียนตัวห่ออเนกประสงค์

เพิ่มฟังก์ชันนี้ใน config.py หรือไฟล์แยก api.py:

import time, requests
from config import PROXIES, BASE
def call(method, payload, retries=6):
for attempt in range(retries):
try:
r = requests.post(f'{BASE}/{method}', json=payload, proxies=PROXIES, timeout=15)
except requests.RequestException as e:
print('เครือข่ายหรือพร็อกซี:', e)
time.sleep(min(2 ** attempt, 30))
continue
if r.status_code == 429:
wait = r.json().get('parameters', {}).get('retry_after', 1)
print('429 Too Many Requests, รอ', wait, 'วินาที')
time.sleep(wait + 0.5)
continue
if 500 <= r.status_code < 600:
print('ข้อผิดพลาดเซิร์ฟเวอร์ Telegram', r.status_code)
time.sleep(min(2 ** attempt, 30))
continue
data = r.json()
if not data.get('ok'):
print('ข้อผิดพลาด API:', data.get('description'))
return data
raise RuntimeError('Telegram Bot API: ใช้ครบจำนวนครั้งแล้วสำหรับ ' + method)

ฟังก์ชันนี้ทำอะไร เมื่อเกิดข้อผิดพลาดเครือข่ายจะรอแบบเอกซ์โพเนนเชียล: 1, 2, 4, 8 วินาที แต่ไม่เกิน 30 บอทจึงทนทานต่อการเปลี่ยน IP บนพร็อกซีหรือช่องทางล้มชั่วคราว เมื่อเจอ 429 อ่าน retry_after บวกครึ่งวินาทีเผื่อ แล้วลองใหม่ เมื่อเจอข้อผิดพลาด 5xx จากฝั่ง Telegram ก็ลองใหม่พร้อมพัก เมื่อเจอข้อผิดพลาด 400 หรือ 403 เช่น ผู้ใช้บล็อกบอท การลองใหม่ไม่มีประโยชน์ ฟังก์ชันจึงคืนคำตอบตามเดิม แล้วคุณตัดสินใจต่อ

จำกัดความเร็วก่อนล่วงหน้า

ดีกว่าที่จะไม่ให้ถึง 429 เลย สำหรับการส่งข้อความเพิ่มหน่วงระหว่างข้อความ วิธีง่ายสุด: time.sleep(0.05) หลังการส่งแต่ละครั้งให้ 20 ข้อความต่อวินาที ซึ่งต่ำกว่าลิมิตโดยรวม สำหรับแชทเดียวให้เว้นอย่างน้อยหนึ่งวินาที สำหรับกลุ่มไม่เกิน 20 ข้อความต่อนาที

def broadcast(chat_ids, text):
sent, failed = 0, 0
for cid in chat_ids:
res = call('sendMessage', {'chat_id': cid, 'text': text})
if res.get('ok'):
sent += 1
else:
failed += 1
time.sleep(0.05)
print('ส่งแล้ว:', sent, 'ผิดพลาด:', failed)

เคล็ดลับ: บันทึกคำตอบที่ผิดพลาดด้วย 403 Forbidden: bot was blocked by the user ลบผู้ใช้เหล่านั้นออกจากฐานข้อมูลส่งข้อความ ช่วยลดโหลดและป้องกันลิมิตเกิน เพราะคำขอที่ล้มเหลวก็ถูกนับด้วย

ทดสอบการจัดการ 429

  1. สร้างกลุ่มทดสอบและเพิ่มบอทเข้าไป
  2. รันลูป 40 ครั้งของ call('sendMessage', {...}) ไปยังแชทนั้นโดยไม่หยุด
  3. สังเกตในคอนโซล: หลังส่งเร็วๆ หลายครั้ง จะมีบรรทัดแจ้ง 429 และเวลารอ
  4. ยืนยันว่าหลังพัก การส่งต่อและข้อความทั้ง 40 ถึงปลายทาง

ตรวจสอบ: ข้อความทั้งหมดส่งถึง บอทไม่ล้มด้วย exception ในล็อกเห็นการพักตาม retry_after แทน requests.post ใน polling.py และ webhook.py ด้วยฟังก์ชัน call เพื่อให้การทำงานกับ Telegram Bot API ทั้งหมดผ่านช่องทางที่ป้องกันแล้วช่องเดียว

ปัญหาที่อาจเกิดขึ้น

  • retry_after สูงมาก หลายร้อยวินาที คุณเพิกเฉยลิมิตมานาน หยุดส่งทั้งหมด รอตามเวลาที่ระบุ แล้วลดความเร็ว
  • 429 มาถึงตั้งแต่ข้อความแรกๆ โปรเซสอื่นใช้โทเคนเดียวกัน ตรวจว่ามีบอทเวอร์ชันเก่ารันอยู่ไหม
  • คำตอบไม่ใช่ JSON เมื่อ 429 พร็อกซีบางตัวคืนหน้า HTML ของตัวเองเมื่อเกิดข้อผิดพลาด ครอบ r.json() ด้วย try และถ้าไม่ได้ให้รอห้าวินาทีคงที่

ขั้นตอนที่ 6: การตั้งค่าขั้นสูงสำหรับโปรเจกต์ที่มีโหลด

เป้าหมาย: เตรียมบอทให้พร้อมขยาย: บอทหลายตัวผ่านพร็อกซีหลายตัว คิวส่งข้อความ Bot API Server ภายใน และการหมุนเวียนที่เหมาะสม ผู้เริ่มต้นข้ามส่วนนี้ได้ แล้วกลับมาเมื่อผู้ใช้เกินพัน

บอทหลายตัวผ่านพร็อกซีต่างกัน

นักการตลาดมักดูแลบอทสิบตัวสำหรับโปรเจกต์ต่างๆ จากเซิร์ฟเวอร์เดียว สถาปัตยกรรมที่ถูกต้อง: แต่ละบอทมีดิกชันนารี proxies ของตัวเองและ session requests.Session() ของตัวเอง Session ใช้การเชื่อมต่อ TCP ซ้ำ ช่วยลดโหลดบนพร็อกซีและเร่งคำขอ 2-3 เท่า เก็บการตั้งค่าเป็นลิสต์: โทเคน ที่อยู่พร็อกซี โหมดรับอัปเดต หนึ่งโปรเซสต่อบอทดีบักง่ายกว่าหนึ่งโปรเซสสำหรับทั้งหมด

คิวส่งข้อความแทนการเรียกตรง

สำหรับการส่งข้อความหาผู้ใช้ตั้งแต่หมื่นคน การเรียกตรงจากโค้ดหลักเริ่มใช้ไม่ได้ ตั้งคิว: Redis หรืออย่างน้อยตารางในฐานข้อมูลที่มีฟิลด์ chat_id, text, status, attempts วอร์กเกอร์แยกดึงงานและเรียกฟังก์ชัน call พร้อมควบคุมความเร็ว เมื่อเจอ 429 วอร์กเกอร์จะนอน ไม่บล็อกการรับ webhook บอทจึงตอบคำสั่งผู้ใช้ต่อได้ระหว่างการส่งข้อความทำงานเบื้องหลัง ในปี 2026 Telegram Bot API อนุญาตให้บอทแบบเสียเงินผ่านพารามิเตอร์ allow_paid_broadcast เพิ่มลิมิตถึง 1000 ข้อความต่อวินาที แต่หัก Stars ดังนั้นสำหรับโปรเจกต์ส่วนใหญ่ คิวที่ 20-25 ข้อความต่อวินาทียังเป็นตัวเลือกที่ดีที่สุด

Bot API Server ภายใน

Telegram เผยแพร่ซอร์สโค้ดของเซิร์ฟเวอร์ Bot API ซึ่งรันเองได้ โค้ดของคุณจะติดต่อ localhost แทน api.telegram.org และเซิร์ฟเวอร์ภายในคุยกับ Telegram เอง ข้อดี: อัปโหลดไฟล์ได้ถึง 2 GB แทน 50 MB, webhook ใช้พอร์ตใดก็ได้และไม่ต้อง HTTPS ภายในเครือข่ายคุณ, ยกเลิกข้อจำกัดหลายอย่าง ข้อเสีย: พร็อกซีต้องตั้งที่ระดับเซิร์ฟเวอร์ภายในเอง ไม่ใช่ในโค้ดบอท ตัวเลือกสำหรับทีมที่มีความสามารถ DevOps สำหรับการเริ่มต้นถือว่ามากเกินไป

การหมุนเวียน IP และ webhook

เมื่อใช้ webhook การหมุนเวียน IP บนพร็อกซีแทบไม่รู้สึก: การเรียก sendMessage แต่ละครั้งสั้น และการตัดการเชื่อมต่อตอนเปลี่ยนมีผลกับคำขอเดียวมากสุด ซึ่งตัวห่อ call จะส่งซ้ำ ดังนั้น webhook ทนการหมุนเวียนบ่อยกว่า polling อย่างไรก็ตาม ไม่มีประโยชน์ที่จะเปลี่ยนบ่อย Telegram Bot API ไม่จำกัดคำขอตาม IP และลิมิตผูกกับโทเคน ตั้งการหมุนเวียนตามความต้องการโครงสร้างพื้นฐานของคุณ ไม่ใช่เพื่อ API

มอนิเตอร์สุขภาพโดยไม่ต้องมีระบบแยก

ชุดขั้นต่ำที่ควรตั้งไว้ตั้งแต่แรก: ทุกนาทีเรียก getWebhookInfo และเขียน pending_update_count กับ last_error_message ลงล็อก ถ้าคิวเพิ่มขึ้นสามครั้งติดกัน ตัวจัดการของคุณรับไม่ไหว สำหรับ polling บันทึกเวลาสำเร็จครั้งสุดท้ายของ getUpdates: ถ้าเกินสองนาที การเชื่อมต่อค้าง ให้รีสตาร์ทโปรเซส เท่านี้ก็รู้ปัญหาก่อนลูกค้า

เคล็ดลับ: ล็อกไม่แค่ข้อผิดพลาด แต่รวมเวลาของทุกคำขอไปยัง Telegram Bot API ผ่านพร็อกซี การเพิ่มขึ้นช้าๆ ของเวลาเฉลี่ยจาก 0.3 เป็น 2 วินาทีจะเตือนการเสื่อมสภาพของช่องทางล่วงหน้าหลายวันก่อนบอทเริ่มทำข้อความหาย

ตรวจสอบผลลัพธ์: เช็กลิสต์โซลูชันพร้อมใช้

ไล่ดูตามรายการ ทุกข้อต้องติ๊กได้ จึงจะถือว่าบอทพร้อมรับผู้ใช้จริง

เช็กลิสต์

  • คำสั่ง curl พร้อมพารามิเตอร์ -x ผ่านพร็อกซีคืน "ok":true ที่เมธอด getMe
  • สคริปต์ check.py แสดง IP พร็อกซี ไม่ใช่ของคุณเอง
  • Polling ตอบข้อความหนึ่งครั้ง ไม่ซ้ำ
  • หลังหยุดและเริ่ม polling ใหม่ ข้อความที่พลาดถูกประมวลผล
  • เมื่อบังคับเปลี่ยน IP บนพร็อกซี polling ฟื้นตัวเองใน 3-5 วินาที
  • Webhook: getWebhookInfo แสดง url ของคุณ, pending_update_count เป็นศูนย์ และ last_error_message ว่างเปล่า
  • คำขอไปยัง webhook ที่ไม่มีส่วนหัวลับได้รับ 403
  • การส่ง 40 ข้อความเร็วๆ ไปยังแชทเดียวผ่านได้โดยไม่ล่ม ในล็อกเห็นการพัก retry_after
  • โทเคนและข้อมูลพร็อกซีอยู่ใน .env ไม่ใช่ในโค้ด

วิธีทดสอบทั้งหมด

  1. เริ่มบอทในโหมดที่เลือก
  2. เขียนหามันจากสามบัญชีต่างกัน บัญชีละสองข้อความ
  3. ยืนยันว่ามีหกคำตอบ หนึ่งต่อหนึ่งข้อความ
  4. กดลิงก์เปลี่ยน IP ในหน้าจัดการพร็อกซี แล้วส่งข้อความอีกทันที
  5. บอทต้องตอบภายใน 10 วินาที
  6. รันการทดสอบ 429 จากขั้นตอนที่ 5
  7. ตรวจล็อก: ไม่มี exception ที่ไม่ถูกจัดการและไม่มี stack trace

ตัวชี้วัดความสำเร็จ

เวลาตอบของบอทต่อข้อความไม่เกิน 2 วินาที อัตราคำขอไม่สำเร็จไปยัง Telegram Bot API หลังการลองซ้ำทั้งหมดต่ำกว่า 0.1 เปอร์เซ็นต์ ไม่มีข้อความซ้ำแม้แต่ครั้งเดียวในหนึ่งวัน pending_update_count ใน getWebhookInfo ไม่เกินสิบในช่วงพีค ถ้าตัวชี้วัดตรงตามนี้ ขอแสดงความยินดี: คุณสร้างระบบที่เชื่อถือได้ ซึ่งจะใช้ได้อีกหลายเดือน

ข้อผิดพลาดทั่วไปและวิธีแก้

ข้อผิดพลาด 409 Conflict เมื่อ getUpdates

สาเหตุ: บอทตั้ง webhook อยู่ หรือมี polling สองอินสแตนซ์รันอยู่ วิธีแก้: เรียก deleteWebhook ผ่านพร็อกซี ยืนยันว่ามีโปรเซสเดียวทำงาน ตรวจคำสั่ง ps aux | grep polling

บอทตอบสองครั้งต่อข้อความ

สาเหตุ: offset ไม่เพิ่ม หรือมีบอทสองชุดรันบนเซิร์ฟเวอร์ต่างกันด้วยโทเคนเดียว วิธีแก้: ตรวจบรรทัด offset = update_id + 1 หยุดชุดที่เกิน สำหรับ webhook ตรวจว่า nginx ไม่ส่งคำขอซ้ำไปยังสองแบ็กเอนด์

ข้อผิดพลาด 407 Proxy Authentication Required

สาเหตุ: ข้อมูลรับรองพร็อกซีผิด หรืออักขระพิเศษในรหัสผ่านไม่ได้ encode วิธีแก้: ตรวจล็อกอินและรหัสผ่านในหน้าจัดการ encode @, : และ / ในรหัสผ่าน ลองยืนยันตัวตนด้วย IP ถ้าแพ็กเกจคุณรองรับ

Read timed out ทุก 50-60 วินาที

สาเหตุ: Timeout ของ polling มากกว่าหรือเท่ากับ timeout ของการว่างบนพร็อกซี วิธีแก้: ลด timeout ใน getUpdates เหลือ 30-40 วินาที และตั้ง timeout ของไคลเอนต์มากกว่า 10 วินาที

ตั้ง webhook แล้วแต่อัปเดตไม่มา

สาเหตุ: พอร์ตปิด ใบรับรองไม่ถูกต้อง หรือตัวจัดการตอบไม่ใช่ 200 วิธีแก้: ดูลายละเอียดใน last_error_message ของ getWebhookInfo นี่คือการวินิจฉัยที่แม่นยำ ตรวจ curl -I https://bot.example.com/tg/webhook จากคอมพิวเตอร์อื่น

Wrong response from the webhook: 403 Forbidden

สาเหตุ: Secret token ในโค้ดต่างจากที่ส่งใน setWebhook วิธีแก้: ตั้ง webhook ใหม่ด้วยค่าเดียวกันกับในโค้ด จำไว้ว่า setWebhook ด้วยพารามิเตอร์ใหม่จะแทนที่ของเดิมทั้งหมด

เจอ 429 บ่อยแม้โหลดน้อย

สาเหตุ: บอทส่งไปยังแชทเดียวบ่อยกว่าวินาทีละครั้ง เช่น ส่งหลายข้อความติดกันตอบคำสั่งเดียว วิธีแก้: รวมคำตอบเป็นข้อความเดียว ใช้ editMessageText แทนข้อความใหม่สำหรับความคืบหน้า เพิ่มหน่วงระหว่างการส่งไปยัง chat_id เดียว

ทราฟฟิกวิ่งตรง ไม่ผ่านพร็อกซี

สาเหตุ: ดิกชันนารี proxies ไม่มีคีย์ https ตัวแปรสภาพแวดล้อมไม่ปรากฏต่อโปรเซส เฟรมเวิร์กไม่รับการตั้งค่า วิธีแก้: ตรวจ IP ขาออกด้วยคำขอไปยัง api.ipify.org ภายในโค้ดเดียวกับที่ส่งข้อความ อย่าเชื่อสมมติฐาน ตรวจสอบจริง

SSL: CERTIFICATE_VERIFY_FAILED เมื่อคำขอผ่านพร็อกซี

สาเหตุ: ชุดใบรับรองรากเก่าหรือเวลาระบบผิด วิธีแก้: อัปเดต certifi ซิงค์เวลา ห้ามปิดการตรวจสอบใบรับรองด้วยพารามิเตอร์ verify=False เด็ดขาด เพราะเปิดโอกาสให้สับเปลี่ยนทราฟฟิกที่มีโทเคน

FAQ: คำถามที่พบบ่อยในการตั้งค่า

เริ่มต้นควรเลือก polling หรือ webhook?

Polling มันทำงานได้จากทุกที่ ไม่ต้องมีโดเมนและใบรับรอง และเปลี่ยนไป webhook ทีหลังได้ภายในหนึ่งชั่วโมง Webhook เหมาะเมื่อบอทให้บริการผู้ใช้หลายพันคนหรือรันบนเซิร์ฟเวอร์ที่มี HTTPS อยู่แล้ว

ใช้พร็อกซีตัวเดียวกับหลายบอทได้ไหม?

ได้ ลิมิต Telegram Bot API ผูกกับโทเคนบอท ไม่ใช่ IP บอทสิบตัวผ่านพร็อกซีเดียวไม่รบกวนกันในมุมของ API ข้อจำกัดเดียวคือแบนด์วิดท์พร็อกซีเอง สำหรับบอทข้อความมีเหลือเฟือ

ต้องให้ webhook และคำตอบผ่านพร็อกซีด้วยไหม?

คำขอขาเข้าของ webhook มาถึงเซิร์ฟเวอร์คุณโดยตรง เป็นไปไม่ได้ตามหลักที่จะให้ผ่านพร็อกซี ผ่านพร็อกซีเฉพาะการเรียกขาออก: sendMessage, setWebhook, getFile และเมธอดอื่น นี่คือรูปแบบปกติและเป็นไปได้เพียงแบบเดียว

จะรู้ได้อย่างไรว่าคำขอผ่านพร็อกซีจริง?

ภายในโค้ดเดียวกัน ขอ https://api.ipify.org ด้วยการตั้งค่า proxies เดียวกัน แล้วเทียบกับ IP จริงของคุณ เพิ่มเติมดูสถิติทราฟฟิกในหน้าจัดการพร็อกซี: ตัวนับต้องเพิ่มขึ้นเมื่อบอททำงาน

ทำอย่างไรเมื่อพร็อกซีเปลี่ยน IP ระหว่างบอททำงาน?

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

SOCKS5 หรือ HTTP proxy สำหรับ Telegram Bot API?

แทบไม่ต่างกันสำหรับบอท ทั้งคู่ใช้ได้ HTTP proxy ตั้งค่าง่ายกว่าและรองรับโดยไคลเอนต์ทั้งหมดโดยไม่ต้องมีแพ็กเกจเพิ่ม SOCKS5 สะดวกกว่าเมื่อคุณต้องการให้ DNS ถูก resolve ที่ฝั่งพร็อกซีผ่าน schema socks5h เลือกอันที่คุณใช้อยู่แล้วในโปรเจกต์อื่น

ส่งได้กี่ข้อความจึงไม่เจอ 429?

ยึดแนวทาง: ไม่เกิน 1 ข้อความต่อวินาทีในแชทส่วนตัว ไม่เกิน 20 ต่อนาทีในกลุ่ม ไม่เกิน 25-30 ต่อวินาทีรวม สำหรับการส่งข้อความจำนวนมาก ตั้งไว้ 20 ข้อความต่อวินาที และต้องจัดการ retry_after เพราะลิมิตอาจลดลงชั่วคราวเมื่อ Telegram มีโหลดสูง

วิธีปลอดภัยในการย้ายบอทที่ทำงานอยู่มาที่พร็อกซี?

ก่อนอื่นตรวจพร็อกซีด้วย curl บน getMe จากนั้นเพิ่มตัวแปร HTTPS_PROXY หรือตั้งค่า proxies ในโค้ด รันบอทด้วยโทเคนทดสอบ หลังตรวจสอบสำเร็จแล้วค่อยสลับไปใช้โทเคนจริง เก็บการตั้งค่าเก่าไว้เผื่อย้อนกลับ

วิธีย้อน webhook กลับมาใช้ polling?

เรียก deleteWebhook ผ่านพร็อกซีหนึ่งครั้ง ถ้าต้องการเก็บอัปเดตที่ค้างไว้สำหรับ polling อย่าส่ง drop_pending_updates หลังจากนั้นเริ่ม polling.py บอทจะรับคิวต่อเอง

ตั้งหลาย URL webhook สำหรับบอทเดียวได้ไหม?

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

บทสรุป

มาสรุปงานที่ทำกัน คุณสร้างบอทและได้โทเคน เรียนรู้การตรวจพร็อกซีผ่าน curl และ Python ยืนยันว่าทราฟฟิกไปยัง Telegram Bot API ไปตามเส้นทางที่ต้องการ คุณสร้างลูป long polling ที่ทนทาน ผ่านการเปลี่ยน IP และไม่ส่งข้อความซ้ำ คุณตั้ง webhook ด้วยใบรับรอง HTTPS จริงและป้องกันด้วย secret token และสิ่งที่มีค่าที่สุด: คุณเขียนฟังก์ชันเดียวที่เคารพ retry_after เมื่อเจอ 429 ส่งคำขอซ้ำเมื่อเครือข่ายล้ม และเปลี่ยนช่องทางที่เอาแน่เอานอนไม่ได้ให้กลายเป็นความน่าเชื่อถือ

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

ทิศทางพัฒนา ศึกษาเมธอด Telegram Bot API สำหรับปุ่มอินไลน์ การชำระเงิน และมินิแอป พวกมันเปิดสถานการณ์ใหม่ให้บอทสำหรับการตลาดและการขายอย่างสิ้นเชิง ฝึกเฟรมเวิร์กแบบอะซิงโครนัส aiogram หรือ python-telegram-bot พวกมันจะรับงานประจำของ polling และการลองซ้ำไปเอง ส่วนคุณก็เข้าใจแล้วว่าเกิดอะไรขึ้นใต้ฝากระโปรง และสำคัญที่สุด: อย่ากลัวที่จะทดลองบนบอททดสอบ ทุกข้อผิดพลาด 429 หรือ 409 ที่คุณจับและแก้เอง ทำให้คุณแข็งแกร่งกว่าเทมเพลตสำเร็จรูปใดๆ คุณทำได้แน่นอน