ในบทความนี้

Web scraping proxy setup by language - Go, Kotlin, Scala, Perl and Elixir - DataImpulse

ในบทความนี้

นี่คือหน้าอ้างอิงมากกว่าจะเป็นบทแนะนำทีละขั้นตอน นั่นคือการตั้งค่า proxy ที่ใช้งานได้จริงสำหรับการทำ scraping ใน 5 ภาษาที่มีกลุ่มผู้ใช้น้อยพอจะทำให้การเขียนคู่มือแยกสำหรับแต่ละภาษาพูดเรื่องเดียวกันซ้ำห้าครั้ง ได้แก่ Go, Kotlin, Scala, Perl และ Elixir พร้อมโค้ด ตัวเลือกไลบรารี และกับดักที่กินเวลามากที่สุดในแต่ละภาษา

กฎที่ใช้ได้กับทุกภาษาเหมือนกันหมด การตั้งค่า proxy สำหรับ web scraping ควรอยู่ที่ client object ตั้งค่าครั้งเดียวแล้วนำกลับมาใช้ซ้ำ เพราะ client ตัวนั้นเองที่พา connection pool, cookie jar และเมื่อใช้ sticky session ก็รวมถึงที่อยู่ทางออก (exit address) ไปด้วย การสร้าง client ใหม่ทุกครั้งต่อ request จะทิ้งทั้งสามอย่างนี้ไปโดยเปล่าประโยชน์


ข้อเท็จจริงสำคัญ

  • กฎเดียวครอบคลุมทุกภาษาที่กล่าวถึงในหน้านี้: ตั้งค่า proxy บน client object เพียงครั้งเดียวแล้วนำ client นั้นกลับมาใช้ซ้ำ เพราะ client คือสิ่งที่พา connection pool คุกกี้ และตัวตนของ exit ไปด้วย
  • Go: http.Transport ร่วมกับ http.ProxyURL และใช้ colly สำหรับงานด้าน crawler กับดักคือ http.Client ไม่มี timeout เริ่มต้น
  • Kotlin: OkHttp พร้อม proxyAuthenticator กับดักคือ authenticator ที่ไม่เคย return null และวนลูปเมื่อรหัสผ่านผิด
  • Scala: sttp พร้อมตัวเลือกของ backend กับดักคือ JDK ปิดการใช้งาน Basic proxy auth บน HTTPS tunnel
  • Perl และ Elixir: LWP จะยึดตามค่า HTTPS_PROXY จาก environment และสามารถแทนที่สิ่งที่ตั้งไว้ในโค้ดได้ ส่วนใน Elixir ตัวเลือกของ proxy เป็นของ adapter ไม่ใช่ของ Req

กฎ 3 ส่วนที่ใช้ได้กับทุกภาษาในหน้านี้

แยก transport, parsing และ scheduling ออกเป็นคนละชั้น แล้วเมื่อการ scrape พังก็จะรู้ทันทีว่าพังตรงไหน

ส่วน รับผิดชอบ อาการเมื่อล้มเหลว
1. Transport การเชื่อมต่อ, proxy, timeout, การลองใหม่ (retry), TLS สถานะที่ไม่ใช่ 200, timeout, ข้อผิดพลาด TLS
2. Parsing แปลง byte เป็นฟิลด์ข้อมูล และแจ้งข้อผิดพลาดชัดเจนเมื่อ markup เปลี่ยน ได้ 200 แต่ฟิลด์ว่างเปล่า
3. Scheduling concurrency ต่อโฮสต์, การจัดจังหวะ (pacing), backoff อัตราความสำเร็จที่ลดลงเรื่อยๆ ในไม่กี่นาที

ทุกภาษาด้านล่างนี้ทำสามส่วนเดียวกันนี้ เพียงแต่เรียกชื่อต่างกัน และในทั้งห้าภาษา proxy จะอยู่ในส่วน transport เสมอ


Go: การตั้งค่า proxy ไลบรารี และกับดักที่ควรเลี่ยง

สแตก: net/http ร่วมกับ http.Transport แบบกำหนดเองสำหรับการดึงข้อมูล ใช้ goquery หรือ colly สำหรับ crawler แบบเต็มรูปแบบในการ parsing และใช้ chromedp เมื่อหน้าเว็บต้องการ JavaScript

proxyURL, _ := url.Parse("http://USER:[email protected]:823")
client := &http.Client{
    Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    Timeout:   30 * time.Second,
}
resp, err := client.Get("https://example.com")

ไม่มี timeout เริ่มต้น http.Client ที่ไม่มีการตั้งค่า Timeout จะรอไปเรื่อยๆ ไม่มีที่สิ้นสุด โฮสต์เดียวที่ค้างอยู่ก็ทำให้ worker pool ทั้งชุดหยุดชะงัก ทั้งที่ metric ทุกตัวที่มีดูเหมือนจะปกติดี

Body ที่ไม่ได้ปิด response body ทุกตัวต้องถูกปิด ไม่เช่นนั้น connection จะไม่ถูกส่งกลับเข้า pool และปริมาณงาน (throughput) จะค่อยๆ ทรุดลงโดยไม่มีสัญญาณเตือนหลังจากผ่านไปไม่กี่พัน request

colly จัดการงานด้าน crawler ให้อัตโนมัติ มันมี proxy switcher สำหรับการ rotate, การจำกัดอัตรา (rate limit) ต่อโดเมน และคิวในตัว จึงควรลองใช้ก่อนที่จะเขียน scheduler ขึ้นมาเอง

ใช้ Go เมื่อ Go เป็นสแตกที่ใช้อยู่แล้ว ต้องการ concurrency สูงพร้อมการใช้หน่วยความจำที่คาดเดาได้ และต้องการ static binary เดี่ยวๆ บนเครื่อง crawler หลีกเลี่ยงเมื่อ เป้าหมายต้องใช้เบราว์เซอร์จริงสำหรับหน้าเว็บส่วนใหญ่ ซึ่งระบบนิเวศของ Python และ Node มีเครื่องมือที่พัฒนามากกว่า


Kotlin: การตั้งค่า proxy ไลบรารี และกับดักที่ควรเลี่ยง

สแตก: OkHttp หรือ Ktor client หากใช้ Ktor อยู่แล้วสำหรับการดึงข้อมูล ใช้ jsoup สำหรับ parsing และใช้ Playwright หรือ Selenium บน JVM เมื่อต้องการการ render

val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress("gw.dataimpulse.com", 823))
val client = OkHttpClient.Builder()
    .proxy(proxy)
    .proxyAuthenticator { _, response ->
        response.request.newBuilder()
            .header("Proxy-Authorization", Credentials.basic("USER", "PASS"))
            .build()
    }
    .callTimeout(Duration.ofSeconds(30))
    .build()

Authenticator วนลูปไม่สิ้นสุดเมื่อรหัสผ่านผิด OkHttp จะเรียก authenticator ซ้ำไปเรื่อยๆ จนกว่าจะยอมแพ้ ควร return null หลังจากพยายามครั้งแรกไม่สำเร็จ ไม่เช่นนั้น credential ที่ผิดจะกลายเป็น request ถล่มใส่ gateway

client เดียว หลาย session OkHttp แชร์ connection pool และ cookie jar ระหว่างการเรียกใช้งานทุกครั้ง หากต้องการตัวตนแยกตาม session ให้สร้าง client แยกต่อ session หรือติดตั้ง cookie jar ที่ควบคุมเอง

กฎเรื่อง tunnelling ของ JDK ที่สร้างปัญหาให้ Java ก็ใช้ที่นี่เหมือนกันหากย้อนกลับไปใช้ JDK client นั่นคือ Basic proxy auth ผ่าน HTTPS ต้องล้างค่า property ของ disabled-schemes ก่อน แต่ authenticator ของ OkHttp เองหลีกเลี่ยงปัญหานี้ได้

ใช้ Kotlin เมื่อ อยู่บน JVM และต้องการ coroutine กับ API ที่ทันสมัยโดยไม่ต้องเจอความยุ่งยากแบบ Java หลีกเลี่ยงเมื่อ ทีมไม่มีประสบการณ์ JVM เพราะเรื่องการ deploy จะกลายเป็นประเด็นหลักมากกว่าตัวโค้ดเอง


Scala: การตั้งค่า proxy ไลบรารี และกับดักที่ควรเลี่ยง

สแตก: sttp ร่วมกับ backend ที่เลือกเองสำหรับการดึงข้อมูล ใช้ jsoup จาก Scala หรือ scala-scraper สำหรับ parsing และใช้ Playwright บน JVM หากหน้าเว็บ render ฝั่ง client

import sttp.client3._

val backend = HttpClientSyncBackend(
  options = SttpBackendOptions.httpProxy(
    "gw.dataimpulse.com", 823, "USER", "PASS")
)

val response = basicRequest
  .get(uri"https://example.com")
  .readTimeout(30.seconds)
  .send(backend)

Backend คือตัวตัดสินใจทุกอย่าง sttp เป็นเพียง interface การรองรับ proxy, timeout และ streaming มาจาก backend ที่เลือกใช้ เมื่อเกิดพฤติกรรมแปลกๆ ให้อ่านเอกสารของ backend นั้นแทนที่จะอ่านของ sttp

ปัญหา JDK tunnelling อีกครั้ง หาก backend ห่อหุ้ม JDK client ไว้ Basic proxy auth ผ่าน HTTPS จะถูกปิดใช้งานโดยค่าเริ่มต้น และต้องล้างค่า property jdk.http.auth.tunneling.disabledSchemes ก่อน

scala-scraper ห่อหุ้ม jsoup ด้วย API แบบ Scala และคุ้มค่าที่จะใช้หากงาน parsing มี selector มากกว่าไม่กี่ตัว

ใช้ Scala เมื่อ crawler ป้อนข้อมูลเข้าสู่ pipeline แบบ Spark หรือ streaming ที่เป็น Scala อยู่แล้ว และเรื่อง backpressure มีความสำคัญ หลีกเลี่ยงเมื่อ งานเป็นเพียงการดึงและ parse ข้อมูลอย่างง่ายโดยไม่มี pipeline ต่อเนื่อง


Perl: การตั้งค่า proxy ไลบรารี และกับดักที่ควรเลี่ยง

สแตก: LWP::UserAgent หรือ Mojo::UserAgent สำหรับ API ที่ทันสมัยกว่าในการดึงข้อมูล ใช้ HTML::TreeBuilder หรือ Mojo::DOM สำหรับ parsing ไม่มีตัวเลือก in-process สำหรับการ render จึงต้องเรียกใช้เครื่องมือภายนอกเมื่อจำเป็นต้อง render

use LWP::UserAgent;
my $ua = LWP::UserAgent->new(timeout => 30);
$ua->proxy(['http','https'] => 'http://USER:[email protected]:823');
my $res = $ua->get('https://example.com');
die $res->status_line unless $res->is_success;

# Mojo equivalent
my $mojo = Mojo::UserAgent->new;
$mojo->proxy->http('http://USER:[email protected]:823')
           ->https('http://USER:[email protected]:823');

HTTPS ผ่าน proxy ต้องใช้โมดูลที่ถูกต้อง LWP ต้องการ LWP::Protocol::https และ IO::Socket::SSL ที่ทำงานได้ปกติ และยังยึดตามค่า environment variable ของ HTTPS_PROXY ซึ่งจะแทนที่สิ่งที่ตั้งไว้ในโค้ดโดยไม่แจ้งเตือนใดๆ

Environment variable ชนะแบบเงียบๆ env_proxy จะดึงค่าที่ตั้งไว้ในระบบซึ่งอาจลืมไปแล้วมาใช้ ควรตั้งค่า proxy อย่างชัดเจนในโค้ด และในงานที่ตั้งเวลาทำงาน (scheduled job) ให้ล้างค่า environment เพื่อไม่ให้การตั้งค่าระดับโฮสต์เปลี่ยนเส้นทางทราฟฟิกได้

Mojo::UserAgent ให้ request แบบ non-blocking และ DOM API ที่คล้าย jQuery มาในดีเพนเดนซีเดียว ทำให้เป็นจุดเริ่มต้นที่ดีกว่าสำหรับผู้ที่เขียน scraper ด้วย Perl ใหม่ๆ

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


Elixir: การตั้งค่า proxy ไลบรารี และกับดักที่ควรเลี่ยง

สแตก: Req บน Finch สำหรับการดึงข้อมูล ใช้ Floki สำหรับ parsing และใช้ Wallaby หรือบริการเบราว์เซอร์ภายนอกเมื่อต้องการการ render

Req.get!("https://example.com",
  connect_options: [
    proxy: {:http, "gw.dataimpulse.com", 823, []},
    proxy_headers: [
      {"proxy-authorization",
       "Basic " <> Base.encode64("USER:PASS")}
    ]
  ],
  receive_timeout: 30_000
)
|> Map.get(:body)
|> Floki.parse_document!()

ตัวเลือกของ proxy เป็นของ adapter Req ส่ง connect_options ลงไปยัง Finch และ Mint หากใช้สแตกแบบเก่าอย่าง HTTPoison หรือ hackney รูปแบบของตัวเลือกจะแตกต่างกัน ซึ่งเป็นเหตุผลที่ code snippet ที่คัดลอกมามักใช้ไม่ได้โดยไม่มีข้อผิดพลาดใดๆ ให้เห็น

process ต่อ URL หนึ่งตัวไม่ใช่แผนที่ดี การ spawn Task ต่อลิงก์หนึ่งลิงก์จะเริ่ม request ทุกตัวพร้อมกันหมด การใช้ Task.async_stream พร้อม max_concurrency ที่กำหนดขนาดตามแต่ละโฮสต์คือวิธีที่เหมาะสมในการจำกัดจำนวน

Floki ร่วมกับ CSS selector ทำให้การ parsing เป็นแบบ declarative และการจัดการ retry กับ redirect ในตัวของ Req ช่วยตัดโค้ดซ้ำซากที่คนมักต้องเขียนเองออกไปได้เกือบทั้งหมด

ใช้ Elixir เมื่อ crawler ทำงานอยู่ภายในระบบ Elixir หรือ Phoenix ที่มีอยู่แล้ว และต้องการ supervision กับ concurrency มาให้ฟรีๆ หลีกเลี่ยงเมื่อ ต้องการ pipeline ที่พึ่งพาเบราว์เซอร์หนักๆ ซึ่งระบบนิเวศยังบางกว่าฝั่ง Node หรือ Python


ควรใช้ภาษาไหนจริงๆ

ปัจจัยตัดสินใจคือเรื่องการดูแลรักษามากกว่าความสามารถของภาษา crawler ที่เขียนด้วยภาษาที่ทีมใช้อยู่ทุกวันจะอยู่รอดผ่านการเปลี่ยนแปลง markup ครั้งต่อไปได้ ส่วน crawler ที่เขียนอย่างชาญฉลาดด้วยภาษาที่ไม่คุ้นเคยมักถูกทิ้งร้างตั้งแต่พังครั้งแรก

ภาษา เหมาะกับ จุดอ่อน
Go concurrency สูงพร้อมการใช้หน่วยความจำที่คาดเดาได้ static binary เดี่ยว เครื่องมือ render เบราว์เซอร์ยังบางกว่า Python หรือ Node
Kotlin องค์กรที่ใช้ JVM และต้องการ coroutine กับ API ที่ทันสมัย ภาระการ deploy ที่มากเกินไปสำหรับงานเล็กๆ
Scala crawler ที่ป้อนข้อมูลเข้าสู่ Spark หรือ streaming pipeline พฤติกรรมที่ขึ้นกับ backend และการตั้งค่าที่ซับซ้อน
Perl งาน ops และเครื่องมือด้านข้อมูลที่ใช้ Perl อยู่แล้ว ไม่มีเบราว์เซอร์แบบ in-process ที่ใช้งานได้จริง
Elixir ระบบ Phoenix ที่ต้องการ supervision และ concurrency มาให้ฟรีๆ ระบบนิเวศของ browser automation ยังบาง

หากภาษาที่ใช้อยู่ไม่ได้อยู่ในรายการนี้ กฎ 3 ส่วนเดียวกันนี้ก็ยังใช้ได้ คู่มือแยกของเราครอบคลุม Java, C#, PHP, R, C++, VBA และ Excel และ JavaScript


อะไรที่เหมือนกันในทุกภาษา และข้อจำกัดอยู่ตรงไหน

มีสามสิ่งที่ไม่เปลี่ยนไปตามภาษาที่ใช้ session เป็นเจ้าของ exit ดังนั้นการเดินทางข้ามหลายหน้าเว็บจะคงที่อยู่ทางออกเดียว (sticky address) ตลอดอายุการใช้งาน กฎเกณฑ์เรื่องนี้อยู่ใน แนวทางปฏิบัติที่ดีที่สุดสำหรับการ rotate proxy การถูกปฏิเสธคือสัญญาณให้วินิจฉัยปัญหามากกว่าจะลองใหม่ทันที ซึ่งคู่มือของเราเรื่อง 403 Forbidden เมื่อทำ scraping อธิบายไว้เป็นลำดับขั้น และ proxy เปลี่ยนแปลงเพียงที่อยู่ทางออกเท่านั้น มันไม่ได้รัน JavaScript ไม่ได้แก้ client ที่ทำงานไม่สอดคล้องกัน และไม่ได้ทำให้อัตราการยิง request ที่ก้าวร้าวกลายเป็นเรื่องที่ยอมรับได้

ในแง่กฎเกณฑ์ ควรเคารพ robots.txt และข้อกำหนดของเว็บไซต์ เลือกใช้ API ที่เป็นทางการก่อน หลีกเลี่ยงสิ่งใดก็ตามที่อยู่หลังการล็อกอิน และมองข้อมูลส่วนบุคคลเป็นประเด็นเรื่องฐานทางกฎหมาย (lawful basis) มากกว่าจะเป็นเรื่องการ parsing เราไม่ได้ครอบคลุมเรื่องการแก้ CAPTCHA หรือการเลี่ยงระบบควบคุมการเข้าถึง นี่คือข้อมูลทั่วไป ไม่ใช่คำแนะนำทางกฎหมาย ดูเพิ่มเติมที่ การทำ web scraping ถูกกฎหมายหรือไม่


คำถามที่พบบ่อย

ตั้งค่า proxy ใน Go อย่างไร

แปลง URL ของ proxy พร้อม credential ด้วยการ parse ใส่ http.ProxyURL ลงใน http.Transport และกำหนด timeout อย่างชัดเจนให้ http.Client เพราะโดยค่าเริ่มต้นแล้วไม่มี timeout เลย นำ client นั้นกลับมาใช้ซ้ำเพื่อให้ connection pool และ sticky session ใดๆ ยังคงอยู่ครบถ้วน

ทำไม proxy authenticator ของ OkHttp ใน Kotlin ถึงวนลูป

เพราะ OkHttp จะเรียก authenticator ซ้ำไปเรื่อยๆ จนกว่าจะสำเร็จหรือยอมแพ้ ควร return null หลังจากพยายามครั้งแรกไม่สำเร็จ เพื่อให้ credential ที่ผิดล้มเหลวอย่างรวดเร็ว แทนที่จะกลายเป็น request ถล่มใส่ gateway

ทำไม Basic proxy auth ถึงใช้ไม่ได้กับ HTTPS บน JVM

JDK ปิดใช้งานการยืนยันตัวตนแบบ Basic บน CONNECT tunnel โดยค่าเริ่มต้น ดังนั้น proxy ที่ต้องยืนยันตัวตนจะทำงานได้กับ HTTP แต่ล้มเหลวกับ HTTPS ให้ล้างค่า property jdk.http.auth.tunneling.disabledSchemes หรือใช้ client อย่าง OkHttp ที่ส่ง header Proxy-Authorization ด้วยตัวเอง

ทำไมสคริปต์ Perl ของฉันถึงไม่ใช้ proxy ที่ตั้งไว้

LWP จะยึดตามค่า environment variable ของ HTTPS_PROXY และ HTTP_PROXY และ env_proxy จะดึงค่าที่ตั้งไว้ระดับโฮสต์ซึ่งอาจไม่รู้ตัวมาใช้ ควรตั้งค่า proxy อย่างชัดเจนในโค้ด และล้างค่า environment ในงานที่ตั้งเวลาทำงานเพื่อไม่ให้การตั้งค่าระดับเครื่องเปลี่ยนเส้นทางทราฟฟิกได้

ตัวเลือกของ proxy ใน Elixir อยู่ที่ไหน

อยู่ที่ adapter ไม่ใช่ที่ Req เอง connect_options จะถูกส่งลงไปยัง Finch และ Mint ซึ่งเป็นเหตุผลที่ code snippet ที่เขียนสำหรับสแตกแบบเก่าที่ใช้ hackney มักไม่ทำงานโดยไม่มีข้อผิดพลาดใดๆ ให้เห็น ควรจับคู่รูปแบบของตัวเลือกให้ตรงกับ adapter ที่ใช้งานจริง


Credential เดียว ใช้ได้กับทุกภาษาข้างต้น

ทุก snippet ในหน้านี้ใช้งานได้กับ credential ของ gateway DataImpulse: exit แบบ residential ในราคา $1 ต่อ GB ครอบคลุม 195 ประเทศ รองรับทั้ง session แบบ rotate และ sticky, HTTP, HTTPS และ SOCKS5 พร้อมการเจาะจงประเทศ (country targeting) สร้างบัญชี และทดสอบกับเป้าหมายเดียวจาก client ของตัวเองก่อนขยายการใช้งาน

ที่เกี่ยวข้อง: proxy สำหรับ web scraping · การตั้งค่า proxy สำหรับ Crawl4AI · use case ของ web scraping

อัปเดตล่าสุด: 17 กันยายน 2026


Share article: