บทความ

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

บทนำ: คุณจะได้อะไร และใครควรอ่านคู่มือนี้

หลังจากทำตามคำแนะนำครบแล้ว คุณจะสามารถตั้งค่าพร็อกซี่ใน Docker ได้ทั้งสามระดับที่ทำได้จริง: สำหรับคอนเทนเนอร์เดียวผ่านตัวแปรสภาพแวดล้อม, สำหรับ Docker client และ daemon ทั้งหมดผ่านไฟล์คอนฟิก และในระดับเครือข่ายผ่านคอนเทนเนอร์เกตเวย์แยกต่างหาก คุณจะเข้าใจว่าระดับเหล่านี้ต่างกันอย่างไร ควรใช้แบบไหนเมื่อไหร่ และจะยืนยันได้อย่างไรว่าทราฟฟิกผ่านพร็อกซี่จริง ไม่ได้วิ่งอ้อมมันไป

คู่มือทีละขั้นตอนนี้เหมาะกับใคร

  • นักการตลาดและผู้เชี่ยวชาญ SMM ที่รันบริการโพสต์อัตโนมัติ วิเคราะห์ หรือมอนิเตอร์ใน Docker และอยากให้ทุกเครื่องมือทำงานด้วยมือถือ IP ของตัวเอง
  • นัก arbitrage ที่มีคอนเทนเนอร์เป็นสิบ ๆ ตัวพร้อม tracker, parser offer และ spy service โดยแต่ละตัวต้องการ geo ที่ต่างกัน
  • นักพัฒนา ที่ต้องทดสอบแอปจากภูมิภาคอื่น หรือรัน integration test ผ่านพร็อกซี่
  • เจ้าของธุรกิจ ที่พนักงานหรือผู้รับเหมาของตน deploy โครงสร้างพื้นฐานในคอนเทนเนอร์ และจำเป็นต้องเข้าใจว่าการทำงานกับพร็อกซี่ในนั้นเป็นอย่างไร

สิ่งที่ควรรู้ล่วงหน้า

เราไม่ต้องการความรู้เชิงลึก แค่คุณเปิดเทอร์มินัลได้ คัดลอกคำสั่งเป็น และอ่านผลลัพธ์ที่มันแสดงออกมาได้ ก็เพียงพอ ถ้าคุณไม่เคยใช้ Docker มาก่อน ไม่ต้องกังวล ในส่วนพื้นฐานเราจะอธิบายศัพท์ทุกคำด้วยภาษาง่าย ๆ ส่วน Kubernetes, การจัดการคลัสเตอร์ และแพลตฟอร์มคลาวด์ เราตั้งใจไม่แตะ เพราะเป็นหัวข้อแยก และที่นี่เราอยู่ในระดับ Docker อย่างเคร่งครัด

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

ถ้าทำครบทั้งหมดพร้อมการตรวจสอบจะใช้เวลา 60–120 นาที ถ้าคุณต้องการแค่สถานการณ์เดียว เช่นพร็อกซี่สำหรับคอนเทนเนอร์เดียว 15 นาทีก็พอ ถ้ายังไม่ได้ติดตั้ง Docker ให้เพิ่มอีก 20–30 นาทีสำหรับการติดตั้ง

การเตรียมตัวเบื้องต้น: เครื่องมือ สิทธิ์การเข้าถึง และข้อกำหนดของระบบ

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

สิ่งที่ต้องเตรียม

  1. คอมพิวเตอร์หรือเซิร์ฟเวอร์ที่มี Docker ใช้ Linux (Ubuntu 22.04 หรือ 24.04, Debian 12), macOS ที่มี Docker Desktop หรือ Windows 10/11 ที่มี Docker Desktop และ WSL2 ก็ได้ ในปี 2026 Docker Engine เวอร์ชัน 27 ขึ้นไปและ Docker Compose v2 ซึ่งเรียกด้วยคำสั่ง docker compose (มีเว้นวรรค ไม่มีขีดกลาง) เป็นเวอร์ชันที่ใช้กันอยู่
  2. ข้อมูลมือถือพร็อกซี่ คุณต้องมีสี่อย่าง: ที่อยู่โฮสต์ (IP หรือโดเมน), พอร์ต, login และรหัสผ่าน หาได้จากหลังบ้านของผู้ให้บริการ และสอบถามด้วยว่าใช้โปรโตคอลไหนได้บ้าง: HTTP หรือ SOCKS5 ผู้ให้บริการมือถือพร็อกซี่ส่วนใหญ่ รวมถึง mobileproxy.space มีทั้งสองแบบบนพอร์ตที่ต่างกัน
  3. เทอร์มินัล บน Linux และ macOS มีในตัว บน Windows ให้ใช้ PowerShell หรือเทอร์มินัล WSL2 (แบบหลังสะดวกกว่าเพราะคำสั่งจะเหมือน Linux ทุกอย่าง)
  4. โปรแกรมแก้ไขข้อความ อะไรก็ได้: nano, vim, VS Code, Notepad++ ใช้แก้ไฟล์คอนฟิก
  5. ยูทิลิตี้ curl โดยปกติติดตั้งมาแล้ว มันช่วยตรวจสอบว่าทราฟฟิกออกด้วย IP ไหน

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

  • RAM ขั้นต่ำ 2 GB และพื้นที่ว่างบนดิสก์ 10 GB สำหรับ Docker และอิมเมจ
  • สิทธิ์ผู้ดูแลระบบ: บน Linux คือการเข้าถึง sudo บน Windows และ macOS คือบัญชีผู้ดูแลระบบสำหรับติดตั้ง Docker Desktop
  • การเชื่อมต่ออินเทอร์เน็ตที่เสถียรสำหรับดาวน์โหลดอิมเมจ

การสำรองข้อมูล

ในขั้นตอนนี้เราจะแก้ไฟล์คอนฟิกของ Docker ข้อผิดพลาดในไฟล์เหล่านี้อาจทำให้ Docker ไม่เริ่มทำงานได้ ดังนั้นก่อนแก้ไฟล์ใด ๆ ให้สำรองไว้ก่อน บน Linux ใช้คำสั่งเดียว:

sudo cp /etc/docker/daemon.json /etc/docker/daemon.json.bak

เช่นเดียวกันกับไฟล์ ~/.docker/config.json ถ้ายังไม่มีไฟล์ก็ไม่ต้องสำรอง แต่จดไว้สักหน่อยว่าคุณสร้างมันขึ้นมาใหม่ เพราะถ้าต้องย้อนกลับก็แค่ลบมันทิ้ง

เคล็ดลับ: สร้างไฟล์ข้อความที่มีเทมเพลตข้อมูลพร็อกซี่ในรูปแบบ protocol://login:password@host:port คุณจะวางสตริงนี้หลายครั้ง และเทมเพลตสำเร็จรูปจะช่วยป้องกันการพิมพ์ผิด

แนวคิดพื้นฐาน: Docker ทำงานอย่างไร และพร็อกซี่อยู่ตรงไหน

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

ศัพท์สำคัญในภาษาง่าย ๆ

  • อิมเมจ (image) คือเทมเพลต ชุดไฟล์และโปรแกรมที่ "แช่แข็ง" ไว้ เช่นอิมเมจที่มี Python หรืออิมเมจที่มีเบราว์เซอร์
  • คอนเทนเนอร์ (container) คือสำเนาของอิมเมจที่กำลังรันอยู่ จากอิมเมจเดียวสามารถรันคอนเทนเนอร์ได้ไม่จำกัด และแต่ละตัวจะแยกออกจากกัน
  • Docker daemon (daemon, dockerd) คือบริการเบื้องหลังที่สร้างคอนเทนเนอร์ ดาวน์โหลดอิมเมจ และจัดการเครือข่าย ตัว daemon นี่เองที่ออกอินเทอร์เน็ตไปเอาอิมเมจเมื่อคุณพิมพ์ docker pull
  • Docker client (docker CLI) คือคำสั่ง docker ในเทอร์มินัล มันส่งคำสั่งของคุณไปยัง daemon
  • ตัวแปรสภาพแวดล้อม (environment variables) คือค่าที่มีชื่อ ซึ่งโปรแกรมในคอนเทนเนอร์เข้าถึงได้ เช่น HTTP_PROXY=http://user:pass@host:port โปรแกรมหลายตัวอ่านตัวแปรเหล่านี้โดยอัตโนมัติและเริ่มออกผ่านพร็อกซี่ที่ระบุ
  • เครือข่าย Docker (network) คือเครือข่ายเสมือนที่เชื่อมคอนเทนเนอร์เข้าด้วยกัน คอนเทนเนอร์ในเครือข่ายผู้ใช้เดียวกันจะมองเห็นกันด้วยชื่อ
  • Docker Compose คือเครื่องมือที่อธิบายคอนเทนเนอร์หลายตัว ตัวแปรของมัน และเครือข่ายไว้ในไฟล์ YAML เดียว แล้วรันทั้งหมดด้วยคำสั่งเดียว

สามระดับของพร็อกซี่ใน Docker

นี่คือส่วนสำคัญที่สุดของทฤษฎี เมื่อมีคนพูดว่า "พร็อกซี่ใน Docker" พวกเขาอาจหมายถึงสามสิ่ง完全不同 กันโดยสิ้นเชิง และแต่ละอย่างก็ตั้งค่าต่างกัน

  1. พร็อกซี่สำหรับ daemon จำเป็นเพื่อให้ตัว Docker ดาวน์โหลดอิมเมจผ่านพร็อกซี่ นี่เกี่ยวกับคำสั่ง docker pull และ docker build ที่ดึงอิมเมจพื้นฐาน ระดับนี้ไม่มีผลต่อทราฟฟิกของแอปในคอนเทนเนอร์ของคุณ
  2. พร็อกซี่สำหรับคอนเทนเนอร์ผ่านตัวแปรสภาพแวดล้อม ส่ง HTTP_PROXY, HTTPS_PROXY และ NO_PROXY เข้าไปในคอนเทนเนอร์ และแอปตัดสินใจเองว่าจะใช้หรือไม่ นี่คือวิธีที่นิยมและง่ายที่สุด แต่ใช้ได้เฉพาะกับโปรแกรมที่ให้ความสำคัญกับตัวแปรเหล่านี้
  3. พร็อกซี่ในระดับเครือข่าย ทราฟฟิกของคอนเทนเนอร์ถูกส่งผ่านคอนเทนเนอร์เกตเวย์อีกตัว หรือผ่านเครือข่ายที่ตั้งค่าเป็นพิเศษ แอปข้างในอาจไม่รู้เรื่องพร็อกซี่เลยก็ได้ วิธีนี้น่าเชื่อถือกว่า แต่ตั้งค่ายุ่งยากกว่า

สิ่งที่ควรเข้าใจก่อนเริ่ม

ตัวแปรสภาพแวดล้อมที่มีพร็อกซี่เป็นเพียงคำแนะนำสำหรับโปรแกรม curl, pip, ไลบรารี requests ใน Python, Node.js กับแพ็กเกจ global-agent, wget, apt ล้วนอ่าน HTTP_PROXY แต่เบราว์เซอร์ในโหมด headless, แอป Go บางตัว และยูทิลิตี้ไบนารีหลายตัวอาจไม่สนใจตัวแปรเหล่านี้ก็ได้ ดังนั้นหลังตั้งค่าเสร็จ ให้ตรวจสอบ IP ภายนอกจริงเสมอ อย่าเชื่อแค่ว่าตัวแปรถูกตั้งไว้แล้ว

อีกจุดที่ต้องระวังคือตัวพิมพ์ Исторически เกิดขึ้นที่โปรแกรมบางส่วนอ่าน http_proxy ตัวพิมพ์เล็ก บางส่วนอ่าน HTTP_PROXY ตัวพิมพ์ใหญ่ แนวทางที่ปลอดภัยคือตั้งทั้งสองแบบพร้อมกัน ตัวแปร NO_PROXY ระบุรายการที่อยู่ซึ่งไม่ต้องใช้พร็อกซี่: localhost, 127.0.0.1, โดเมนภายใน, ชื่อคอนเทนเนอร์ข้างเคียง

สุดท้ายคือรูปแบบที่อยู่พร็อกซี่ สำหรับ HTTP พร็อกซี่ สตริงจะดูเป็น http://login:password@host:port สำหรับ SOCKS5 คือ socks5://login:password@host:port หรือ socks5h://login:password@host:port ตัวอักษร h ท้ายสุดหมายความว่าคำขอ DNS ก็ออกผ่านพร็อกซี่ด้วย ซึ่งโดยทั่วไปดีกว่าสำหรับมือถือพร็อกซี่ เพราะเว็บเป้าหมายจะไม่เห็น DNS resolver ของผู้ให้บริการของคุณ

ขั้นตอนที่ 1: ตรวจสอบ Docker และเตรียมข้อมูลพร็อกซี่

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

ตรวจสอบ Docker

  1. เปิดเทอร์มินัล
  2. พิมพ์ docker --version แล้วกด Enter คุณควรเห็นบรรทัดแบบ Docker version 27.x.x ถ้าเทอร์มินัลบอกว่าไม่พบคำสั่ง แสดงว่ายังไม่ได้ติดตั้ง Docker ให้ติดตั้ง Docker Desktop (Windows, macOS) หรือ Docker Engine (Linux) ตามเอกสารทางการแล้วกลับมาตรงนี้
  3. พิมพ์ docker compose version ผลลัพธ์ที่คาดหวัง: Docker Compose version v2.x.x
  4. พิมพ์ docker run --rm hello-world Docker จะดาวน์โหลดอิมเมจทดสอบขนาดจิ๋วและแสดงข้อความทักทายที่มีคำว่า Hello from Docker นี่หมายความว่า daemon ทำงานและคุณมีสิทธิ์รันคอนเทนเนอร์

เคล็ดลับ: ถ้าบน Linux คำสั่ง docker ต้องใช้ sudo ให้เพิ่มตัวเองเข้ากลุ่ม docker: sudo usermod -aG docker $USER แล้วออกจากระบบและเข้าใหม่ หลังจากนั้นคำสั่งทั้งหมดในคู่มือนี้จะใช้ได้โดยไม่ต้อง sudo

ตรวจสอบพร็อกซี่จากโฮสต์

ก่อนจะพาพร็อกซี่เข้าไปในคอนเทนเนอร์ มาตรวจสอบว่ามันตอบสนองจริง ใส่ข้อมูลของคุณแทนตัวอย่าง ในตัวอย่างเราจะใช้ที่อยู่ 185.10.10.10, พอร์ต 1050 สำหรับ HTTP และ 1051 สำหรับ SOCKS5, login user123 และรหัสผ่าน secret แน่นอนว่าคุณจะมีค่าของคุณเอง

  1. ก่อนอื่นหา IP ปกติของคุณโดยไม่ใช้พร็อกซี่: curl -s ifconfig.me จดหรือจำผลลัพธ์ไว้
  2. ตอนนี้ยิงคำขอผ่าน HTTP พร็อกซี่: curl -s -x http://user123:secret@185.10.10.10:1050 ifconfig.me
  3. ถ้าคุณใช้ SOCKS5: curl -s -x socks5h://user123:secret@185.10.10.10:1051 ifconfig.me
  4. เปรียบเทียบผลลัพธ์กับขั้นที่ 1 IP ต้องต่างกันและเป็นของผู้ให้บริการมือถือ

อักขระพิเศษในรหัสผ่าน

ถ้า login หรือรหัสผ่านมีอักขระ @, :, /, #, ? หรือเว้นวรรค ต้องเข้ารหัสแบบ URL มิฉะนั้นสตริงพร็อกซี่จะพัง อักขระ @ กลายเป็น %40, : เป็น %3A, / เป็น %2F, # เป็น %23, ? เป็น %3F, เว้นวรรคเป็น %20 ตัวอย่างเช่น รหัสผ่าน pa@ss เขียนในสตริงพร็อกซี่เป็น pa%40ss

✅ ตรวจสอบ: คำสั่ง curl ผ่านพร็อกซี่คืน IP ที่ต่างจากที่บ้าน และตอบกลับภายในหนึ่งถึงสามวินาที ถ้าเจอข้อผิดพลาด 407 ให้ตรวจ login และรหัสผ่าน ถ้า Connection refused หรือ timeout ให้ตรวจโฮสต์ พอร์ต และดูว่ามีการเพิ่ม IP ปัจจุบันของคุณเข้า whitelist ในหลังบ้านผู้ให้บริการหรือยัง (บางแพ็กเกจเปิดการยืนยันตัวตนด้วย IP เป็นค่าเริ่มต้น)

ขั้นตอนที่ 2: ตั้งค่าพร็อกซี่สำหรับคอนเทนเนอร์เดียวผ่านตัวแปรสภาพแวดล้อม

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

รันด้วยแฟล็ก -e

แฟล็ก -e (หรือ --env) ของคำสั่ง docker run ส่งตัวแปรสภาพแวดล้อมเข้าไปในคอนเทนเนอร์ เราจะส่งสี่ตัวแปรพร้อมกัน: พร็อกซี่สำหรับ HTTP, สำหรับ HTTPS และข้อยกเว้น แต่ละตัวในสองตัวพิมพ์

  1. คัดลอกคำสั่งด้านล่างไปยังเอดิเตอร์ แล้วแทนที่ข้อมูลพร็อกซี่ด้วยของคุณ
  2. รันคำสั่งในเทอร์มินัล มันจะรันคอนเทนเนอร์ชั่วคราวที่มี curl ยิงคำขอแล้วจบ
docker run --rm -e HTTP_PROXY=http://user123:secret@185.10.10.10:1050 -e HTTPS_PROXY=http://user123:secret@185.10.10.10:1050 -e http_proxy=http://user123:secret@185.10.10.10:1050 -e https_proxy=http://user123:secret@185.10.10.10:1050 -e NO_PROXY=localhost,127.0.0.1 -e no_proxy=localhost,127.0.0.1 curlimages/curl -s ifconfig.me

สังเกตว่า HTTPS_PROXY เราก็ระบุ http:// ข้างหน้าด้วย ไม่ใช่ข้อผิดพลาด นี่คือวิธีระบุพร็อกซี่ที่คำขอ HTTPS จะผ่าน ส่วนการเชื่อมต่อกับพร็อกซี่เซิร์ฟเวอร์เองเป็นแบบธรรมดา สคีมา https:// ในค่า HTTPS_PROXY จะหมายความว่าต้องเชื่อมต่อถึงพร็อกซี่ผ่าน TLS ซึ่งผู้ให้บริการส่วนใหญ่ไม่รองรับ

ไฟล์ตัวแปรแทนคำสั่งยาว

คำสั่งยาวพอดู Docker อ่านตัวแปรจากไฟล์ผ่านแฟล็ก --env-file ได้ สะดวกและปลอดภัยกว่า: รหัสผ่านไม่ค้างใน history ของเทอร์มินัล

  1. สร้างไฟล์ proxy.env ในโฟลเดอร์ทำงาน: nano proxy.env
  2. เขียนบรรทัดลงไป หนึ่งตัวแปรต่อบรรทัด ไม่มีเครื่องหมายคำพูดและไม่มีเว้นวรรครอบเครื่องหมายเท่ากับ:
HTTP_PROXY=http://user123:secret@185.10.10.10:1050 HTTPS_PROXY=http://user123:secret@185.10.10.10:1050 http_proxy=http://user123:secret@185.10.10.10:1050 https_proxy=http://user123:secret@185.10.10.10:1050 NO_PROXY=localhost,127.0.0.1 no_proxy=localhost,127.0.0.1

ในไฟล์จริง แต่ละตัวแปรต้องอยู่บรรทัดแยก บันทึกไฟล์ (ใน nano คือ Ctrl+O, Enter แล้ว Ctrl+X) และรันคอนเทนเนอร์:

docker run --rm --env-file proxy.env curlimages/curl -s ifconfig.me

ตรวจสอบจากในคอนเทนเนอร์ที่กำลังรัน

บ่อยครั้งที่ต้องดูว่าคอนเทนเนอร์อายุยืนมองเห็นอะไร รัน Alpine Linux ในโหมดอินเทอร์แอกทีฟและตรวจตัวแปร

  1. รัน docker run -it --rm --env-file proxy.env alpine sh คุณจะเข้าไปอยู่ในคอนเทนเนอร์ พร้อมต์เปลี่ยนเป็นเครื่องหมายชาร์ปหรือดอลลาร์
  2. พิมพ์ env | grep -i proxy คุณจะเห็นรายการตัวแปรของคุณ
  3. พิมพ์ apk add --no-cache curl ตัวจัดการแพ็กเกจ apk จะรับ https_proxy เองและดาวน์โหลดแพ็กเกจผ่านพร็อกซี่
  4. พิมพ์ curl -s ifconfig.me และยืนยันว่า IP เป็นมือถือ
  5. พิมพ์ exit เพื่อออก คอนเทนเนอร์จะลบตัวเองอัตโนมัติเพราะแฟล็ก --rm

เคล็ดลับ: นอกจาก ifconfig.me แล้ว การใช้บริการที่คืน JSON พร้อมข้อมูลประเทศ เมือง และผู้ให้บริการก็สะดวก วิธีนี้คุณจะเห็นทันทีว่า IP เป็นของผู้ให้บริการมือถือในภูมิภาคที่ต้องการ ไม่ใช่แค่ "IP อื่น"

✅ ตรวจสอบ: การรัน curl ทั้งสองครั้งคืน IP ของมือถือพร็อกซี่ คำสั่ง env ภายในคอนเทนเนอร์แสดงตัวแปร HTTP_PROXY และ HTTPS_PROXY พร้อมข้อมูลของคุณ

ปัญหาที่อาจเจอในขั้นนี้

  • IP ไม่เปลี่ยน แอปในคอนเทนเนอร์ไม่สนใจตัวแปร สำหรับ curl ไม่มีทางเป็นแบบนี้ ดังนั้นถ้า curl แสดง IP มือถือแต่แอปคุณไม่แสดง ให้ไปที่วิธีแบบเครือข่ายในขั้นที่ 6
  • ข้อผิดพลาด invalid reference format มักเกิดจากเว้นวรรคเกินหรือขึ้นบรรทัดใหม่ในคำสั่ง ให้ประกอบคำสั่งเป็นบรรทัดเดียว
  • มองไม่เห็นตัวแปร ในไฟล์ env-file ต้องไม่มีเครื่องหมายคำพูดครอบค่า เพราะ Docker จะส่งมันไปตามตัวอักษร และที่อยู่พร็อกซี่จะไม่ถูกต้อง

ขั้นตอนที่ 3: ตั้งค่าพร็อกซี่สำหรับ Docker client เพื่อให้ตัวแปรถูกส่งอัตโนมัติ

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

มันทำงานอย่างไร

Docker client อ่านไฟล์ config.json ในโฟลเดอร์ ~/.docker (บน Windows คือโฟลเดอร์ .docker ในโปรไฟล์ผู้ใช้) ถ้าในนั้นมีเซกชัน proxies client จะเพิ่มตัวแปรที่ระบุลงในคอนเทนเนอร์ทุกครั้งที่ docker run และ docker build ส่วน daemon ไม่ถูกแตะ ดังนั้น docker pull จะยังออกตรงตามเดิม

การตั้งค่าทีละขั้นตอน

  1. ตรวจว่ามีไฟล์หรือไม่: cat ~/.docker/config.json ถ้าไฟล์มีอยู่และมีการตั้งค่าอยู่แล้ว (เช่น auths ที่มีข้อมูล login เข้า registry) ให้สำรอง: cp ~/.docker/config.json ~/.docker/config.json.bak
  2. เปิดไฟล์ในเอดิเตอร์: nano ~/.docker/config.json ถ้าไฟล์ไม่มี เอดิเตอร์จะสร้างให้
  3. เพิ่มเซกชัน proxies ถ้าไฟล์ว่างเปล่า เนื้อหาทั้งหมดจะเป็นแบบนี้:
{ "proxies": { "default": { "httpProxy": "http://user123:secret@185.10.10.10:1050", "httpsProxy": "http://user123:secret@185.10.10.10:1050", "noProxy": "localhost,127.0.0.1,*.local" } } }

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

  1. บันทึกไฟล์
  2. ตรวจสอบไวยากรณ์ บน Linux และ macOS ใช้แบบนี้สะดวก: python3 -m json.tool ~/.docker/config.json ถ้าผลลัพธ์แสดงไฟล์ของคุณซ้ำในรูปแบบจัดสวยก็ใช้ได้ ถ้ามีข้อผิดพลาดพร้อมหมายเลขบรรทัดก็แก้ตรงนั้น
  3. รันคอนเทนเนอร์ตรวจสอบโดยไม่ใช้แฟล็กใด ๆ: docker run --rm curlimages/curl -s ifconfig.me IP ต้องเป็นมือถือ
  4. ดูตัวแปรของคอนเทนเนอร์ใดก็ได้: docker run --rm alpine env ในผลลัพธ์จะมี HTTP_PROXY, HTTPS_PROXY, NO_PROXY และรุ่นพิมพ์เล็ก: Docker เพิ่มทั้งสองตัวพิมพ์ให้เอง

⚠ ข้อควรระวัง: เซกชัน proxies ใน config.json มีผลกับทุกคอนเทนเนอร์ที่คุณรันจากผู้ใช้คนนี้ รวมถึงฐานข้อมูล เว็บเซิร์ฟเวอร์ภายใน และอื่น ๆ ทั้งหมด ถ้าบริการใดคุยกับ API ภายนอกที่เข้าถึงไม่ได้ผ่านพร็อกซี่ของคุณ มันจะพัง ให้เพิ่มที่อยู่เหล่านั้นใน noProxy หรือชั่วคราวเอาซекชันออก

พร็อกซี่ต่างกันสำหรับการเชื่อมต่อต่างกัน

คีย์ default ใช้กับการเชื่อมต่อทั้งหมดกับ daemon ถ้าคุณจัดการ Docker host หลายตัวผ่าน context หรือตัวแปร DOCKER_HOST แทนที่จะใช้ default สามารถระบุที่อยู่ของ daemon นั้นได้ เช่น tcp://192.168.1.50:2376 และพร็อกซี่จะใช้กับตัวนั้นเท่านั้น สำหรับงานในเครื่อง default ก็เพียงพอ

พร็อกซี่ตอน build อิมเมจ

การตั้งค่าใน config.json ถูกส่งไปใน docker build เป็น build argument ด้วย นั่นหมายความว่าคำสั่ง RUN apt-get install หรือ RUN pip install ใน Dockerfile จะผ่านพร็อกซี่ จุดสำคัญ: ตัวแปรเหล่านี้ไม่ถูกเก็บในอิมเมจสุดท้าย ซึ่งดีในแง่ความปลอดภัย: รหัสผ่านพร็อกซี่จะไม่รั่วไปยังคนที่คุณส่งอิมเมจให้

เคล็ดลับ: ถ้าต้องการส่งพร็อกซี่เฉพาะการ build ครั้งเดียวโดยไม่แตะ config.json ให้ใช้แฟล็ก docker build --build-arg HTTP_PROXY=http://user123:secret@185.10.10.10:1050 --build-arg HTTPS_PROXY=http://user123:secret@185.10.10.10:1050 . Docker เข้าใจ build argument ที่กำหนดไว้ล่วงหน้าเหล่านี้โดยไม่ต้องประกาศ ARG ใน Dockerfile

✅ ตรวจสอบ: คอนเทนเนอร์ที่รันโดยไม่มีแฟล็ก -e ออกอินเทอร์เน็ตด้วย IP ของพร็อกซี่ คำสั่ง docker run --rm alpine env แสดงตัวแปรพร็อกซี่

วิธีย้อนกลับ

ลบเซกชัน proxies ออกจาก config.json หรือกู้ไฟล์จากสำรอง: cp ~/.docker/config.json.bak ~/.docker/config.json ไม่ต้องรีสตาร์ท การเปลี่ยนแปลงมีผลกับการรันคอนเทนเนอร์ครั้งถัดไป

ขั้นตอนที่ 4: ตั้งค่าพร็อกซี่สำหรับ Docker daemon เพื่อให้อิมเมจดาวน์โหลดผ่านพร็อกซี่

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

วิธีที่ 1: ไฟล์ daemon.json (Linux, Docker 23 ขึ้นไป)

  1. สำรองไฟล์: sudo cp /etc/docker/daemon.json /etc/docker/daemon.json.bak (ถ้าไม่มีไฟล์ คำสั่งจะแจ้งข้อผิดพลาด ถือว่าปกติ)
  2. เปิดไฟล์: sudo nano /etc/docker/daemon.json
  3. เพิ่มเซกชัน proxies:
{ "proxies": { "http-proxy": "http://user123:secret@185.10.10.10:1050", "https-proxy": "http://user123:secret@185.10.10.10:1050", "no-proxy": "localhost,127.0.0.1" } }

สังเกตว่าคีย์ตรงนี้เขียนด้วยขีดกลางและตัวพิมพ์เล็ก ซึ่งต่างจาก config.json ของ client ที่คีย์เป็นแบบ httpProxy การสับสนระหว่างสองแบบนี้เป็นข้อผิดพลาดคลาสสิก

  1. บันทึกไฟล์และรีสตาร์ท daemon: sudo systemctl restart docker
  2. ตรวจว่า daemon ขึ้นมาแล้ว: sudo systemctl status docker ในผลลัพธ์ต้องมี active (running)
  3. ตรวจว่ามีผล: docker info | grep -i proxy คุณจะเห็นบรรทัด HTTP Proxy และ HTTPS Proxy พร้อมที่อยู่ของคุณ โดยรหัสผ่านในผลลัพธ์จะถูกซ่อนด้วยเครื่องหมายดอกจัน

วิธีที่ 2: drop-in ไฟล์ systemd (Linux, ทุกเวอร์ชัน)

นี่คือวิธีคลาสสิกที่ใช้ได้แม้กับ Docker เวอร์ชันเก่า

  1. สร้างโฟลเดอร์: sudo mkdir -p /etc/systemd/system/docker.service.d
  2. สร้างไฟล์: sudo nano /etc/systemd/system/docker.service.d/http-proxy.conf
  3. เขียนเนื้อหา แต่ละ directive อยู่บรรทัดแยก:
[Service] Environment="HTTP_PROXY=http://user123:secret@185.10.10.10:1050" Environment="HTTPS_PROXY=http://user123:secret@185.10.10.10:1050" Environment="NO_PROXY=localhost,127.0.0.1"
  1. บันทึก แล้วโหลดคอนฟิก systemd ใหม่: sudo systemctl daemon-reload
  2. รีสตาร์ท Docker: sudo systemctl restart docker
  3. ตรวจสอบ: sudo systemctl show --property=Environment docker ในผลลัพธ์จะมีตัวแปรของคุณ

⚠ ข้อควรระวัง: อย่าตั้งค่าพร็อกซี่ daemon ด้วยสองวิธีพร้อมกัน ถ้าทั้ง daemon.json และไฟล์ systemd มีที่อยู่ต่างกัน พฤติกรรมจะคาดเดาไม่ได้และการดีบักจะทรมาน ให้เลือกวิธีเดียวและยึดตามนั้น

วิธีที่ 3: Docker Desktop (Windows และ macOS)

  1. เปิด Docker Desktop คลิกไอคอนเฟืองมุมขวาบน
  2. ในเมนูซ้ายเลือก Resources แล้ว Proxies
  3. เลื่อนสวิตช์ Manual proxy configuration ให้เป็นเปิด
  4. ในช่อง Web Server (HTTP) และ Secure Web Server (HTTPS) วางที่อยู่พร็อกซี่ในรูปแบบ http://user123:secret@185.10.10.10:1050
  5. ในช่อง Bypass proxy settings for these hosts เขียน localhost,127.0.0.1
  6. กด Apply and restart Docker Desktop จะรีสตาร์ท ใช้เวลา 30–60 วินาที

Docker Desktop ใช้การตั้งค่าเหล่านี้กับทั้ง daemon และคอนเทนเนอร์พร้อมกัน ดังนั้นการแก้ config.json แยกบนระบบเดสก์ท็อปมักไม่จำเป็น

ตรวจสอบผลลัพธ์

  1. ลบอิมเมจเล็ก ๆ สักตัวถ้ามี: docker rmi alpine
  2. ดาวน์โหลดอีกครั้ง: docker pull alpine การดาวน์โหลดต้องสำเร็จ
  3. ถ้าฝั่งพร็อกซี่มีสถิติทราฟฟิก (ในหลังบ้าน mobileproxy.space มี) คุณจะเห็นปริมาณทราฟฟิกที่ใช้เพิ่มขึ้นหลายเมกะไบต์

✅ ตรวจสอบ: docker info แสดงที่อยู่พร็อกซี่, docker pull ดาวน์โหลดอิมเมจได้ไม่มีข้อผิดพลาด, บริการ docker อยู่ในสถานะ active

ปัญหาที่อาจเจอ

  • Docker ไม่เริ่มหลังแก้ daemon.json เกือบทุกครั้งเป็นเพราะไวยากรณ์ JSON ให้ตรวจไฟล์ด้วยคำสั่ง python3 -m json.tool /etc/docker/daemon.json หรือกู้จากสำรอง
  • docker pull ค้าง พร็อกซี่ไม่ผ่านการเชื่อมต่อไปยัง registry หรือเกินลิมิตทราฟฟิกของแพ็กเกจ ให้ตรวจพร็อกซี่จากโฮสต์ด้วย curl เหมือนในขั้นที่ 1
  • ข้อผิดพลาด x509 certificate พร็อกซี่เปลี่ยนใบรับรอง (เกิดกับพร็อกซี่ในองค์กร สำหรับมือถือพร็อกซี่พบได้น้อย) ให้สอบถามผู้ให้บริการ

ขั้นตอนที่ 5: ตั้งค่าพร็อกซี่ใน Docker Compose

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

เตรียมโปรเจกต์

  1. สร้างโฟลเดอร์โปรเจกต์และเข้าไป: mkdir proxy-demo แล้ว cd proxy-demo
  2. สร้างไฟล์ .env (มีจุดนำหน้า) สำหรับเก็บความลับ: nano .env
  3. เขียนตัวแปร หนึ่งตัวต่อบรรทัด:
PROXY_MSK=http://user123:secret@185.10.10.10:1050 PROXY_KZN=http://user456:secret2@185.10.10.20:1050

ไฟล์ .env ที่ Compose อ่านโดยอัตโนมัติ และค่าจากมันสามารถแทนใน compose.yaml ผ่านไวยากรณ์ ${ชื่อ} ให้เพิ่ม .env ใน .gitignore ถ้าโปรเจกต์อยู่ภายใต้ระบบควบคุมเวอร์ชัน: รหัสผ่านไม่ควรเข้า repo

ไฟล์ compose.yaml

สร้างไฟล์ compose.yaml (nano compose.yaml) และอธิบายสามเซอร์วิส ใน YAML การย่อหน้าสำคัญ: ใช้สองเว้นวรรคต่อระดับ ไม่ใช้แท็บ

services: parser-msk: image: curlimages/curl command: -s ifconfig.me environment: HTTP_PROXY: ${PROXY_MSK} HTTPS_PROXY: ${PROXY_MSK} http_proxy: ${PROXY_MSK} https_proxy: ${PROXY_MSK} NO_PROXY: localhost,127.0.0.1,db no_proxy: localhost,127.0.0.1,db parser-kzn: image: curlimages/curl command: -s ifconfig.me environment: HTTP_PROXY: ${PROXY_KZN} HTTPS_PROXY: ${PROXY_KZN} http_proxy: ${PROXY_KZN} https_proxy: ${PROXY_KZN} NO_PROXY: localhost,127.0.0.1,db no_proxy: localhost,127.0.0.1,db db: image: postgres:16-alpine environment: POSTGRES_PASSWORD: example

ในไฟล์จริง แต่ละบรรทัดอยู่แยกกันพร้อมการย่อหน้าที่ถูกต้อง: services อยู่ระดับศูนย์ ชื่อเซอร์วิสย่อสองเว้นวรรค พารามิเตอร์ของมันย่อสี่ และตัวแปรสภาพแวดล้อมย่อหก สังเกตชื่อ db ใน NO_PROXY: วิธีนี้ parser จะเข้าถึงฐานข้อมูลตรงผ่านเครือข่าย Docker ภายใน ไม่พยายามไปถึงมันผ่านมือถือพร็อกซี่ ซึ่งไม่มีทางสำเร็จ

รันและตรวจสอบ

  1. ตรวจว่า Compose แทนตัวแปรอย่างไร: docker compose config คำสั่งจะแสดงไฟล์สุดท้ายที่ค่าเปิดเผยแล้ว ยืนยันว่าแทน ${PROXY_MSK} ด้วยที่อยู่จริง
  2. รัน: docker compose up Compose จะดาวน์โหลดอิมเมจและรันทั้งสามเซอร์วิส แสดง log ในเทอร์มินัล
  3. ใน log คุณจะเห็นบรรทัดแบบ parser-msk-1 | 91.xxx.xxx.xxx และ parser-kzn-1 | 176.xxx.xxx.xxx สอง IP ต่างกันจากสองพร็อกซี่ต่างกัน Postgres จะเริ่มและรอการเชื่อมต่อ
  4. หยุดทั้งหมดด้วย Ctrl+C แล้วลบคอนเทนเนอร์: docker compose down

ทางเลือก: env_file สำหรับแต่ละเซอร์วิส

ถ้าตัวแปรมีเยอะ แทนที่จะใช้บล็อก environment ให้ระบุไฟล์สะดวกกว่า:

services: parser-msk: image: curlimages/curl command: -s ifconfig.me env_file: - proxy-msk.env

ไฟล์ proxy-msk.env มีหกบรรทัดเดียวกันกับ proxy.env ในขั้นที่ 2 วิธีนี้พร็อกซี่แต่ละตัวอยู่ในไฟล์ของตัวเอง และเปลี่ยนได้โดยไม่ต้องเปิด compose.yaml

พร็อกซี่ตอน build ใน Compose

ถ้าเซอร์วิสสร้างจาก Dockerfile ไม่ได้ใช้ของสำเร็จ ให้ส่งพร็อกซี่เข้า build ผ่าน build.args:

services: app: build: context: . args: HTTP_PROXY: ${PROXY_MSK} HTTPS_PROXY: ${PROXY_MSK}

วิธีนี้ pip, npm หรือ apt ใน Dockerfile จะทำงานผ่านพร็อกซี่ และค่าไม่เข้าไปในอิมเมจสุดท้าย

เคล็ดลับ: Compose รองรับหลายไฟล์ ให้เก็บ compose.yaml พื้นฐานที่ไม่มีพร็อกซี่ และใน compose.proxy.yaml อธิบายแค่บล็อก environment รัน docker compose -f compose.yaml -f compose.proxy.yaml up เมื่อต้องการพร็อกซี่ และรันแค่ docker compose up เมื่อไม่ต้องการ สะดวกตอนดีบัก: คุณสลับระหว่างโหมดได้ในวินาทีเดียว

✅ ตรวจสอบ: docker compose config แสดงที่อยู่พร็อกซี่ที่แทนแล้ว และใน log ของ docker compose up เซอร์วิสที่มีพร็อกซี่ต่างกันแสดง IP ต่างกัน

ขั้นตอนที่ 6: ตั้งค่าพร็อกซี่ในระดับเครือข่ายผ่านคอนเทนเนอร์เกตเวย์

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

ทำไมต้องมีเกตเวย์ถ้ามีตัวแปรอยู่แล้ว

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

สร้างเครือข่าย

  1. สร้างเครือข่ายผู้ใช้: docker network create proxynet
  2. ยืนยันว่ามันปรากฏแล้ว: docker network ls ในรายการจะมี proxynet ที่มีไดรเวอร์ bridge

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

รันเกตเวย์

ในฐานะเกตเวย์เราใช้ gost ซึ่งเป็นพร็อกซี่เซิร์ฟเวอร์ขนาดกระทัดรัดที่รับการเชื่อมต่อบนโปรโตคอลหนึ่งและส่งต่อไปยังอีกโปรโตคอลหนึ่งพร้อมการยืนยันตัวตนได้ อิมเมจมีใน registry สาธารณะในชื่อ gogost/gost

  1. รันคอนเทนเนอร์เกตเวย์:
docker run -d --name gateway --network proxynet --restart unless-stopped gogost/gost -L=http://:8118 -F=http://user123:secret@185.10.10.10:1050

มาดูพารามิเตอร์ แฟล็ก -d รันคอนเทนเนอร์เบื้องหลัง แฟล็ก --name gateway กำหนดชื่อที่เพื่อนบ้านจะใช้ แฟล็ก --network proxynet เชื่อมมันกับเครือข่ายของเรา แฟล็ก --restart unless-stopped ยกเกตเวย์หลังรีบูตเซิร์ฟเวอร์ พารามิเตอร์ -L=http://:8118 บอก gost ให้รับการเชื่อมต่อ HTTP พร็อกซี่บนพอร์ต 8118 โดยไม่ต้องยืนยันตัวตน พารามิเตอร์ -F ระบุว่าจะส่งต่อไปไหน: ไปยังมือถือพร็อกซี่ของคุณพร้อม login และรหัสผ่าน

  1. ตรวจว่าเกตเวย์ทำงาน: docker logs gateway ใน log ต้องมีบรรทัดว่าเซิร์ฟเวอร์ฟังอยู่บนพอร์ต 8118 โดยไม่มีข้อผิดพลาด

⚠ ข้อควรระวัง: อย่าเปิดพอร์ตเกตเวย์ออกภายนอกด้วยแฟล็ก -p ถ้าไม่จำเป็นจริง ๆ เกตเวย์ทำงานโดยไม่ต้องยืนยันตัวตน และพอร์ต 8118 ที่เปิดบนเซิร์ฟเวอร์สาธารณะหมายความว่าใครก็ได้บนอินเทอร์เน็ตใช้มือถือพร็อกซี่ของคุณและใช้ทราฟฟิกของคุณได้ ภายในเครือข่าย proxynet มันเข้าถึงได้เฉพาะคอนเทนเนอร์ของคุณ และเท่านี้ก็เพียงพอ

เชื่อมคอนเทนเนอร์ที่ทำงาน

  1. รันคอนเทนเนอร์ตรวจสอบในเครือข่ายเดียวกัน ระบุเกตเวย์เป็นพร็อกซี่:
docker run --rm --network proxynet -e HTTP_PROXY=http://gateway:8118 -e HTTPS_PROXY=http://gateway:8118 curlimages/curl -s ifconfig.me
  1. คุณควรเห็น IP ของมือถือพร็อกซี่ สังเกตว่าในตัวแปรไม่มี login รหัสผ่าน หรือที่อยู่จริงของพร็อกซี่ มีแต่เกตเวย์เท่านั้นที่รู้ทั้งหมดนี้

แบบเดียวกันใน Compose

สำหรับการทำงานถาวร ให้อธิบายเกตเวย์และเซอร์วิสที่ทำงานใน compose.yaml เดียวกัน:

services: gateway: image: gogost/gost command: -L=http://:8118 -F=${PROXY_MSK} restart: unless-stopped networks: - proxynet worker: image: curlimages/curl command: -s ifconfig.me environment: HTTP_PROXY: http://gateway:8118 HTTPS_PROXY: http://gateway:8118 NO_PROXY: localhost,127.0.0.1 depends_on: - gateway networks: - proxynet networks: proxynet: driver: bridge

directive depends_on รับประกันว่าเกตเวย์เริ่มก่อน worker ค่า PROXY_MSK มาจากไฟล์ .env เหมือนในขั้นที่ 5

หลายเกตเวย์สำหรับหลาย geo

อยากได้พร็อกซี่ต่างกันสำหรับกลุ่มคอนเทนเนอร์ต่างกัน? ยกเกตเวย์หลายตัว: gateway-msk, gateway-kzn, gateway-spb แต่ละตัวมี -F ของตัวเอง คอนเทนเนอร์ที่ทำงานแค่ระบุชื่อที่ต้องการใน HTTP_PROXY ก็พอ จะไปไกลกว่านั้นได้โดยสร้างเครือข่ายแยกต่อ geo หนึ่งเครือข่าย แล้วคอนเทนเนอร์ในกลุ่มมอสโกก็จะไม่สามารถบังเอิญไปเข้าเกตเวย์คาซานได้โดยทางกายภาพ

การแยก: คอนเทนเนอร์ที่ไม่มีทางออกอินเทอร์เน็ตตรง

วิธีที่เข้มงวดที่สุดคือห้ามคอนเทนเนอร์ที่ทำงานออกอินเทอร์เน็ตทุกทาง ยกเว้นผ่านเกตเวย์ ทำได้โดยสร้างเครือข่ายภายในด้วยแฟล็ก --internal: docker network create --internal isolated คอนเทนเนอร์ในเครือข่ายแบบนี้ไม่มีเส้นทางออกข้างนอก ให้เชื่อมเกตเวย์เข้ากับสองเครือข่ายพร้อมกัน (isolated และ proxynet ปกติ) ส่วน worker เชื่อมเฉพาะ isolated เท่านั้น ตอนนี้แม้แอปไม่สนใจตัวแปรพร็อกซี่ มันก็ไม่อาจออกอินเทอร์เน็ตตรงได้เลย และไม่มีการรั่ว IP จริง

  1. docker network create --internal isolated
  2. docker network connect isolated gateway
  3. docker run --rm --network isolated -e HTTP_PROXY=http://gateway:8118 -e HTTPS_PROXY=http://gateway:8118 curlimages/curl -s ifconfig.me
  4. เพื่อควบคุม ให้รันคอนเทนเนอร์เดิมโดยไม่มีตัวแปรพร็อกซี่: docker run --rm --network isolated curlimages/curl -s -m 5 ifconfig.me คำขอต้องหมดเวลา: ไม่มีทางออกตรง

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

✅ ตรวจสอบ: คอนเทนเนอร์ในเครือข่าย proxynet ที่มีตัวแปร HTTP_PROXY=http://gateway:8118 แสดง IP ของมือถือพร็อกซี่ คอนเทนเนอร์ในเครือข่ายภายในที่ไม่มีพร็อกซี่ไม่อาจออกอินเทอร์เน็ตได้เลย

ปัญหาที่อาจเจอ

  • Could not resolve host: gateway คอนเทนเนอร์ที่ทำงานไม่ได้อยู่ในเครือข่ายนั้น หรือรันในเครือข่ายเริ่มต้นที่ชื่อไม่ถูกแก้ ตรวจแฟล็ก --network
  • เกตเวย์รีสตาร์ทเอง ข้อผิดพลาดในสตริง -F: พิมพ์รหัสผ่านผิดหรือพอร์ตไม่ถูก ดู docker logs gateway
  • ช้า มือถือพร็อกซี่ช้ากว่าพร็อกซี่ดาต้าเซ็นเตอร์โดยธรรมชาติ แต่ถ้าดีเลย์เป็นสิบ ๆ วินาที ให้ตรวจว่า DNS ไม่ได้ออกอ้อม: ใช้ socks5h แทน socks5 ในสตริง -F ถ้าผู้ให้บริการให้ SOCKS5

ตรวจสอบผลลัพธ์: เช็กลิสต์พร็อกซี่ใน Docker ที่ทำงานได้

ไล่ตามรายการ ถ้าทุกข้อถูกทำเครื่องหมาย แสดงว่าคุณเชี่ยวชาญการตั้งค่าพร็อกซี่ใน Docker ครบถ้วนแล้ว

เช็กลิสต์

  • curl จากโฮสต์ผ่านพร็อกซี่คืน IP มือถือ
  • คอนเทนเนอร์ที่มีแฟล็ก --env-file proxy.env คืน IP มือถือ
  • คอนเทนเนอร์ที่ไม่มีแฟล็กใด ๆ หลังตั้งค่า config.json คืน IP มือถือ (ถ้าคุณทำขั้นที่ 3)
  • docker info แสดงที่อยู่พร็อกซี่ และ docker pull ทำงานได้ (ถ้าคุณทำขั้นที่ 4)
  • docker compose up รันเซอร์วิส และใน log เห็น IP ต่างกันสำหรับพร็อกซี่ต่างกัน
  • คอนเทนเนอร์เกตเวย์ทำงาน เพื่อนบ้านออกผ่านมันโดยไม่ต้องมี login และรหัสผ่าน
  • คอนเทนเนอร์ในเครือข่ายภายในที่ไม่มีพร็อกซี่ไม่อาจออกอินเทอร์เน็ตได้

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

  1. รันคอนเทนเนอร์อายุยืน: docker run -d --name test --network proxynet -e HTTP_PROXY=http://gateway:8118 -e HTTPS_PROXY=http://gateway:8118 alpine sleep 3600
  2. เข้าไปในนั้น: docker exec -it test sh
  3. ติดตั้ง curl: apk add --no-cache curl การติดตั้งต้องผ่านพร็อกซี่
  4. ยิงคำขอห้าครั้งติดต่อกัน: for i in 1 2 3 4 5; do curl -s ifconfig.me; echo; done ทั้งห้าครั้งต้องคืน IP มือถือ ถ้าพร็อกซี่ของคุณตั้งหมุนเวียนอัตโนมัติ IP อาจต่างกันระหว่างคำขอ ซึ่งปกติ
  5. ออก (exit) และลบคอนเทนเนอร์: docker rm -f test

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

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

ข้อผิดพลาดทั่วไปในการตั้งค่าพร็อกซี่ใน Docker และวิธีแก้

ข้อผิดพลาดที่ 1: IP ไม่เปลี่ยน แม้ตัวแปรถูกตั้งไว้

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

วิธีแก้: ตรวจเอกสารของแอปเรื่องแฟล็กพร็อกซี่ของตัวเอง (ของเบราว์เซอร์มักเป็น --proxy-server) ถ้าไม่มีแฟล็ก ให้ใช้เกตเวย์และเครือข่ายภายในจากขั้นที่ 6 หรือการพร็อกซี่แบบโปร่งใสจากส่วนสำหรับผู้ขั้นสูง

ข้อผิดพลาดที่ 2: 407 Proxy Authentication Required

สาเหตุ: login หรือรหัสผ่านผิด หรืออักขระพิเศษในนั้นไม่ได้เข้ารหัส หรือพร็อกซี่เปิดการยืนยันตัวตนด้วย IP และ IP ของเซิร์ฟเวอร์ไม่อยู่ใน whitelist

วิธีแก้: ตรวจข้อมูลจากโฮสต์ด้วย curl เข้ารหัสอักขระพิเศษ เพิ่ม IP ของเซิร์ฟเวอร์ใน whitelist ในหลังบ้าน หรือสลับพร็อกซี่ไปใช้การยืนยันตัวตนด้วย login และรหัสผ่าน

ข้อผิดพลาดที่ 3: Docker ไม่เริ่มหลังแก้ daemon.json

สาเหตุ: ข้อผิดพลาดไวยากรณ์ใน JSON: จุลภาคเกิน เครื่องหมายคำพูดตก หรือคีย์ในสไตล์ config.json แทนสไตล์ daemon.json

วิธีแก้: ดู log: sudo journalctl -u docker -n 50 มันจะระบุบรรทัดที่มีข้อผิดพลาด แก้หรือกู้จากสำรองและรีสตาร์ทบริการ

ข้อผิดพลาดที่ 4: คอนเทนเนอร์มองไม่เห็นกันอีกต่อไป

สาเหตุ: หลังตั้งค่าพร็อกซี่ส่วนกลางใน config.json คำขอไปยังคอนเทนเนอร์ข้างเคียงก็ผ่านมือถือพร็อกซี่ด้วย ซึ่งไม่รู้จัก db หรือ redis

วิธีแก้: เพิ่มชื่อเซอร์วิสและซับเน็ตภายในใน NO_PROXY: localhost,127.0.0.1,db,redis,172.16.0.0/12 ระลึกว่าไม่ใช่ทุกโปรแกรมเข้าใจมาสก์ซับเน็ต ดังนั้นการระบุชื่อให้ชัดเจนจึงน่าเชื่อถือกว่า

ข้อผิดพลาดที่ 5: docker build ล้มที่ apt-get หรือ pip

สาเหตุ: การ build ไม่ผ่านพร็อกซี่ เพราะตัวแปรถูกตั้งสำหรับคอนเทนเนอร์ ไม่ใช่สำหรับการ build หรือพร็อกซี่ของ daemon ถูกตั้ง แต่ไม่มีผลกับขั้น RUN

วิธีแก้: ส่ง --build-arg HTTP_PROXY และ HTTPS_PROXY หรือตั้งเซกชัน proxies ใน config.json ของ client: มันใช้กับการ build ด้วย

ข้อผิดพลาดที่ 6: รหัสผ่านพร็อกซี่ปรากฏใน docker inspect และ log

สาเหตุ: ตัวแปรสภาพแวดล้อมถูกเก็บใน metadata ของคอนเทนเนอร์แบบเปิดเผย และใครก็ตามที่เข้าถึง Docker จะเห็นมันผ่าน docker inspect

วิธีแก้: ใช้เกตเวย์: คอนเทนเนอร์ที่ทำงานรู้แค่ที่อยู่ gateway:8118 รหัสผ่านอยู่ในคอนเทนเนอร์เดียวและในไฟล์ .env ที่มีสิทธิ์จำกัด (chmod 600 .env)

ข้อผิดพลาดที่ 7: หลังรีบูตเซิร์ฟเวอร์พร็อกซี่ไม่ทำงานอีก

สาเหตุ: คอนเทนเนอร์เกตเวย์ไม่ได้รันด้วยนโยบายรีสตาร์ท หรือ IP ของมือถือพร็อกซี่เปลี่ยนไป

วิธีแก้: เพิ่ม --restart unless-stopped ให้เกตเวย์ ใช้ชื่อโดเมนของพร็อกซี่แทน IP ถ้าผู้ให้บริการมีให้ ตรวจ docker ps -a: ถ้าเกตเวย์อยู่ในสถานะ Exited ให้ดู log ของมัน

ข้อผิดพลาดที่ 8: เว็บ HTTPS ไม่เปิด แต่ HTTP ทำงาน

สาเหตุ: ตั้งแค่ HTTP_PROXY แต่ HTTPS_PROXY ว่าง หรือใน HTTPS_PROXY ระบุสคีมา https:// แทน http://

วิธีแก้: ตั้งทั้งสองตัวแปรด้วยค่าและสคีมา http:// เดียวกันเสมอ

ความสามารถเพิ่มเติมสำหรับผู้ขั้นสูง: การพร็อกซี่แบบโปร่งใส การหมุนเวียน IP และความปลอดภัย

ส่วนนี้สำหรับคนที่ผ่านขั้นพื้นฐานมาแล้วและอยากดึงศักยภาพสูงสุดจาก Docker และมือถือพร็อกซี่ ที่นี่มีรายการทีละขั้นน้อยลงและมีไอเดียพร้อมคำสั่งสำคัญมากขึ้น

การพร็อกซี่แบบโปร่งใส: เมื่อแอปไม่รู้เรื่องพร็อกซี่เลย

ถ้าคุณมีแอปที่ไม่สามารถทำงานกับพร็อกซี่ได้เลย คุณสามารถห่อทราฟฟิก TCP ทั้งหมดของมันในระดับสแตกเครือข่ายได้ แนวคิดคือ: คอนเทนเนอร์ที่ทำงานถูกรันด้วยพารามิเตอร์ network_mode: service:gateway (ใน Compose) หรือ --network container:gateway (ใน docker run) วิธีนี้มันใช้สแตกเครือข่ายของคอนเทนเนอร์เกตเวย์ทั้งหมด: IP เดียวกัน อินเทอร์เฟซเดียวกัน กฎเส้นทางเดียวกัน

ในเกตเวย์จะมีโปรแกรมอย่าง redsocks ฟังพอร์ตภายในและส่งต่อการเชื่อมต่อไปยัง SOCKS5 พร็อกซี่ ส่วนกฎ iptables เบี่ยงทราฟฟิก TCP ขาออกทั้งหมดไปพอร์ตนั้น เกตเวย์ต้องมีสิทธิ์: cap_add: NET_ADMIN แอปในคอนเทนเนอร์ที่ทำงานยิงคำขอปกติไปเว็บไซต์ เคอร์เนลดักจับและส่งไป redsocks และมันไปมือถือพร็อกซี่ ไม่มีตัวแปรสภาพแวดล้อมเลย การตั้งค่าต้องรอบคอบ: กฎ iptables ที่ผิดอาจวนทราฟฟิกได้ ดังนั้นทดสอบบนเครื่องแยก โปรดระวังว่าเมื่อใช้ network_mode: service คอนเทนเนอร์ที่ทำงานจะเสียพอร์ตของตัวเองและการเชื่อมต่อเครือข่ายอื่น ต้องอธิบายทั้งหมดบนเกตเวย์

การหมุนเวียน IP จากคอนเทนเนอร์

มือถือพร็อกซี่มีคุณสมบัติพิเศษที่ทำให้คนเลือกใช้: เปลี่ยน IP ได้ตามคำขอ ผู้ให้บริการมีลิงก์เปลี่ยน IP พิเศษ แค่เปิดมันก็ทำให้โมเด็ม reconnect จากคอนเทนเนอร์ทำได้ด้วย curl แบบแผนที่มีประโยชน์: เซอร์วิสเล็ก ๆ แยกใน Compose ที่ดึงลิงก์หมุนเวียนตามตาราง มันไม่ควรผ่านพร็อกซี่ (มิฉะนั้นหลังเปลี่ยน IP มันจะเสียการเชื่อมต่อเอง) ดังนั้นรันมันโดยไม่มีตัวแปรพร็อกซี่หรือตั้ง HTTP_PROXY ว่างชัดเจน ระลึกว่าหลังเปลี่ยน IP การเชื่อมต่อที่ใช้งานของคอนเทนเนอร์จะถูกตัด: ออกแบบ parser ให้ลองใหม่ได้

สุขภาพเกตเวย์: healthcheck

เพิ่มการตรวจใน Compose ว่าเกตเวย์พร็อกซี่จริง ไม่ใช่แค่รันอยู่:

healthcheck: test: ["CMD", "gost", "-V"] interval: 30s timeout: 10s retries: 3

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

การเก็บรหัสผ่านอย่างปลอดภัย

ไฟล์ .env ดีสำหรับงานในเครื่อง แต่บนเซิร์ฟเวอร์ที่มีผู้ใช้หลายคนควรป้องกัน: chmod 600 .env เจ้าของคือผู้ใช้ที่รัน Compose Compose ยังรองรับ secrets ผ่าน directive secrets ซึ่งเมานต์เข้าไปในคอนเทนเนอร์เป็นไฟล์ใน /run/secrets/ ไม่ใช่ตัวแปรสภาพแวดล้อม Gost ไม่อ่านรหัสผ่านจากไฟล์โดยตรง แต่คุณเขียนสคริปต์ห่อเล็ก ๆ ที่ประกอบสตริง -F จากไฟล์ secret ตอนเริ่มได้ วิธีนี้รหัสผ่านจะไม่ปรากฏใน docker inspect หรือผลลัพธ์ docker compose config

หลายโปรเจกต์และโครงสร้างพื้นฐานพร็อกซี่เดียว

ถ้าคุณมีโปรเจกต์ Compose หลายตัวและพร็อกซี่ใช้ร่วมกัน ให้แยกเกตเวย์ไปโปรเจกต์แยกพร้อมเครือข่ายภายนอก: ในนั้นประกาศ networks พร้อมพารามิเตอร์ name: proxynet และโปรเจกต์อื่นเชื่อมเป็น external: true วิธีนี้เกตเวย์อยู่แยก และโปรเจกต์ที่ทำงานรีสตาร์ทได้ไม่จำกัดโดยไม่แตะพร็อกซี่

จำกัดทราฟฟิก

ทราฟฟิกมือถือมักคิดค่าบริการ และ parser ที่หลุดตัวเดียวอาจดึงหลายสิบ GB ในคืนเดียว ในระดับ Docker ไม่มีโควต้าทราฟฟิกแบบเข้มงวด แต่มีมาตรการทางอ้อม: จำกัดอัตราคำขอในแอปเอง จำกัดอายุคอนเทนเนอร์ผ่าน timeout ในคำสั่งรัน และมอนิเตอร์ผ่าน docker stats ซึ่งแสดง NET I/O ของแต่ละคอนเทนเนอร์แบบเรียลไทม์ เทียบตัวเลขเหล่านี้กับสถิติในหลังบ้านผู้ให้บริการเป็นประจำ

Log ที่ไม่มี secret

แอปหลายตัวพิมพ์ตัวแปรสภาพแวดล้อมใน log ตอนเริ่ม รวมถึง HTTP_PROXY พร้อมรหัสผ่าน ถ้า log ส่งไประบบศูนย์กลาง รหัสผ่านจะรั่วไปที่นั่นด้วย เกตเวย์แก้ปัญหานี้เช่นกัน: ใน log ของคอนเทนเนอร์ที่ทำงานจะมีแค่ gateway:8118

เคล็ดลับ: เปลี่ยนรหัสผ่านพร็อกซี่ทุกไตรมาสและอัปเดต .env กับเกตเวย์ใช้เวลาแค่หนึ่งนาที: แก้บรรทัดเดียว รัน docker compose up -d gateway และ worker ทั้งหมดทำงานต่อโดยไม่ต้องรีสตาร์ท

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

ต้องรีสตาร์ทคอนเทนเนอร์เพื่อใช้ตัวแปรพร็อกซี่ใหม่ไหม

ต้อง ตัวแปรสภาพแวดล้อมถูกกำหนดตอนสร้างคอนเทนเนอร์และเปลี่ยนในคอนเทนเนอร์ที่ทำงานอยู่ไม่ได้ ให้หยุด ลบ และสร้างคอนเทนเนอร์ใหม่ (ใน Compose คือ docker compose up -d --force-recreate ชื่อเซอร์วิส) ถ้าการรีสตาร์ทเป็นอุปสรรค ให้ใช้เกตเวย์: ตั้งค่าของมันเปลี่ยนได้อย่างอิสระ

การตั้งค่าพร็อกซี่สำหรับ docker pull ต่างจากพร็อกซี่สำหรับแอปในคอนเทนเนอร์อย่างไร

นี่เป็นสองระดับที่ต่างกัน docker pull ทำงานโดย daemon และพร็อกซี่ของมันตั้งใน daemon.json หรือผ่าน systemd แอปในคอนเทนเนอร์เป็นโพรเซสแยกที่มีสภาพแวดล้อมของตัวเอง พร็อกซี่ของมันตั้งด้วยตัวแปร, config.json ของ client หรือเครือข่าย อย่างหนึ่งไม่แทนที่อีกอย่าง

ใช้ SOCKS5 แทน HTTP พร็อกซี่ในตัวแปรสภาพแวดล้อมได้ไหม

ได้ ถ้าแอปรองรับ SOCKS curl, Python requests (พร้อมแพ็กเกจ PySocks), git รองรับ apt และอื่น ๆ อีกมากไม่รองรับ ทางออกสากล: เกตเวย์ gost ที่รับ HTTP ที่ขาเข้าและส่งไป SOCKS5 ที่ขาออก: -L=http://:8118 -F=socks5://user:pass@host:port

จะตรวจได้อย่างไรว่าคอนเทนเนอร์ที่รันอยู่ใช้พร็อกซี่ไหน

รัน docker inspect -f '{{.Config.Env}}' ชื่อคอนเทนเนอร์ คุณจะเห็นตัวแปรสภาพแวดล้อมทั้งหมด สำหรับตรวจ IP จริงใช้ docker exec ชื่อคอนเทนเนอร์ curl -s ifconfig.me ถ้าในคอนเทนเนอร์มี curl หรือ wget -qO- ifconfig.me

ทำไมใน Docker Desktop พร็อกซี่ทำงาน แต่บนเซิร์ฟเวอร์ Linux ตั้งค่าเดิมกลับไม่ทำงาน

Docker Desktop ใช้การตั้งค่าจากหน้าต่าง Proxies กับทั้ง daemon และคอนเทนเนอร์พร้อมกัน บน Linux เป็นสองที่แยกกัน: daemon.json สำหรับ daemon และ ~/.docker/config.json สำหรับคอนเทนเนอร์ ตรวจว่าคุณตั้งทั้งสองถ้าต้องการทั้งสอง

จะตั้งพร็อกซี่เฉพาะโดเมนเดียวและให้ที่เหลือออกตรงได้อย่างไร

ตัวแปรสภาพแวดล้อมทำแบบนั้นไม่ได้: มันทำงานตามหลัก "ทั้งหมดผ่านพร็อกซี่ ยกเว้น NO_PROXY" ถ้าต้องการตรรกะกลับกัน ให้ใช้ไฟล์ PAC ฝั่งแอป (เบราว์เซอร์รองรับ) หรือกฎเส้นทางใน gost ซึ่งส่งทราฟฟิกไปช่องทางขาออกต่างกันตามโดเมนได้

เก็บรหัสผ่านพร็อกซี่ใน compose.yaml ปลอดภัยไหม

ไม่ควรอย่างยิ่ง เก็บใน .env ที่มีสิทธิ์ 600 และแทนผ่าน ${ชื่อ} อย่า commit .env เข้า repo สำหรับเซิร์ฟเวอร์ให้ใช้เกตเวย์ เพื่อให้รหัสผ่านอยู่ที่เดียว

ทำอย่างไรถ้ามือถือพร็อกซี่เปลี่ยน IP และการเชื่อมต่อในคอนเทนเนอร์ขาด

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

การตั้งค่าเหล่านี้ใช้ได้บน Windows โดยไม่มี WSL2 ไหม

Docker Desktop บน Windows ใช้ WSL2 หรือ Hyper-V ข้างใต้ และคำสั่ง docker run และ docker compose ทั้งหมดทำงานเหมือนกันจาก PowerShell ต่างแค่เส้นทาง: ไฟล์ config.json อยู่ที่ C:\Users\ชื่อผู้ใช้\.docker\config.json และการตั้งค่า daemon ทำผ่านหน้าต่าง Docker Desktop ไม่ใช่แก้ daemon.json ด้วยมือ

ส่งคอนเทนเนอร์ได้กี่ตัวผ่านมือถือพร็อกซี่ตัวเดียว

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

สรุป: คุณทำอะไรไปแล้วและไปต่อที่ไหน

มาสรุปกัน คุณตรวจสอบการทำงานของพร็อกซี่จากโฮสต์และเข้าใจรูปแบบสตริงการเชื่อมต่อ ตั้งค่าพร็อกซี่สำหรับคอนเทนเนอร์เดียวผ่านตัวแปรสภาพแวดล้อมและไฟล์ env-file ทำให้การส่งตัวแปรเป็นอัตโนมัติผ่าน config.json ของ client เข้าใจวิธีและเหตุผลในการตั้งค่าพร็อกซี่สำหรับ Docker daemon สามวิธี อธิบายหลายเซอร์วิสพร้อมมือถือพร็อกซี่ต่างกันใน Docker Compose พร้อมแยกความลับไปที่ .env และสุดท้าย สร้างคอนเทนเนอร์เกตเวย์พร้อมเครือข่ายแยก ซึ่งเป็นทางออกที่น่าเชื่อถือที่สุดสำหรับโปรดักชัน ป้องกันการรั่ว IP จริงแม้แอปไม่สนใจตัวแปร

ตอนนี้พร็อกซี่ใน Docker สำหรับคุณไม่ใช่กล่องดำอีกต่อไป แต่เป็นสามระดับที่เข้าใจได้ชัดเจนพร้อมขอบเขตชัดเจน: daemon, คอนเทนเนอร์, เครือข่าย คุณรู้ว่าจะหาปัญหาที่ไหนถ้า IP กลายเป็นตัวอื่น และตรวจสอบได้ในคำสั่งเดียว

ทำอะไรต่อ

  1. ย้ายโปรเจกต์ที่ทำงานมาใช้แบบแผนเกตเวย์และเครือข่ายภายใน เริ่มจากเซอร์วิสที่ไม่สำคัญสักตัว ยืนยันว่าทุกอย่างทำงาน แล้วค่อยขยาย
  2. เพิ่มคอนเทนเนอร์มอนิเตอร์ที่ตรวจ IP ภายนอกผ่านเกตเวย์ทุกนาทีและแจ้งเตือนถ้ามันตรงกับ IP เซิร์ฟเวอร์
  3. ตั้งการหมุนเวียน IP ตามตารางให้เหมาะกับงานของคุณ และสอนแอปให้รับมือการเชื่อมต่อขาดได้
  4. จัดระเบียบความลับ: .env ที่มีสิทธิ์ 600 ไม่มีรหัสผ่านใน compose.yaml และ Dockerfile

ไปพัฒนาต่อที่ไหน

ขั้นตอนตรรกะถัดไปคือเชื่อม Docker กับเบราว์เซอร์ антидетект และเครื่องมือหลายบัญชี ที่แต่ละโปรไฟล์มีคอนเทนเนอร์และมือถือพร็อกซี่ของตัวเอง อีกทิศทางคือระบบอัตโนมัติผ่าน API ของผู้ให้บริการ: ดึงรายการพร็อกซี่ ตรวจสถานะและหมุนเวียนจากเซอร์วิสของคุณโดยตรง ทั้งสองหัวข้ออยู่นอกขอบเขตคู่มือนี้ แต่พื้นฐานที่คุณวางไว้ตอนนี้ทำให้มันง่ายขึ้นมาก ขอให้รันราบรื่นและ IP เสถียร!