Proxy trong Go: cấu hình http.Client với máy chủ proxy

```html

Nếu bạn đang viết một trình phân tích, tự động hóa việc thu thập dữ liệu hoặc kiểm tra API từ các khu vực khác nhau — sớm hay muộn bạn sẽ gặp phải các khối theo IP. Go là một trong những ngôn ngữ phổ biến nhất để viết các công cụ mạng hiệu suất cao, và việc cấu hình proxy ở đây có những đặc điểm riêng. Trong hướng dẫn này, chúng ta sẽ xem xét mọi thứ từ cấu hình cơ bản http.Client đến việc xoay vòng IP nâng cao với hỗ trợ SOCKS5.

Tại sao cần proxy trong ứng dụng Go

Go đã trở thành tiêu chuẩn de facto cho việc viết các công cụ mạng có tải cao: trình phân tích, trình thu thập dữ liệu, bot theo dõi giá, công cụ tự động hóa API. Chính tại đây nhu cầu về proxy thường xuất hiện nhất — và chính tại đây việc cấu hình mọi thứ đúng ngay từ đầu là rất quan trọng.

Các kịch bản chính khi không thể thiếu proxy:

Phân tích các thị trường trực tuyến — Wildberries, Ozon, AliExpress chặn IP sau 50–200 yêu cầu từ một địa chỉ. Nếu không thay đổi IP, trình phân tích sẽ dừng lại.
Kiểm tra địa lý — kiểm tra kết quả tìm kiếm, quảng cáo hoặc giá từ các quốc gia và khu vực khác nhau.
Vượt qua giới hạn tần suất — phân phối tải qua nhiều IP cho phép vượt qua các giới hạn về số lượng yêu cầu mỗi phút.
Ẩn danh — ẩn địa chỉ IP thực của máy chủ khi làm việc với các API bên ngoài.
Kiểm tra CDN và định vị địa lý — kiểm tra tính chính xác của việc cung cấp nội dung cho các khu vực khác nhau.

Thư viện tiêu chuẩn của Go cung cấp các công cụ linh hoạt để làm việc với proxy — thông qua http.Transport và http.Client. Chúng ta sẽ xem xét từng cách một cách chi tiết.

Cấu hình cơ bản HTTP-proxy qua http.Client

Trong Go, proxy được cấu hình ở cấp độ http.Transport — lớp vận chuyển của HTTP-client. Điều này cho phép kiểm soát hoàn toàn cách các yêu cầu đi qua proxy nào và cho phép tạo nhiều client với các proxy khác nhau cùng một lúc.

Ví dụ tối thiểu về cấu hình HTTP-proxy:

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    // Chỉ định địa chỉ máy chủ proxy
    proxyURL, err := url.Parse("http://123.45.67.89:8080")
    if err != nil {
        panic(err)
    }

    // Tạo một transport với proxy
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    // Tạo một client với transport của chúng ta
    client := &http.Client{
        Transport: transport,
    }

    // Thực hiện yêu cầu qua proxy
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Điều gì xảy ra trong đoạn mã này:

url.Parse — phân tích chuỗi với địa chỉ proxy thành cấu trúc *url.URL
http.Transport{Proxy: http.ProxyURL(proxyURL)} — tạo một transport, hướng tất cả các yêu cầu qua proxy đã chỉ định
http.Client{Transport: transport} — tạo một client với transport của chúng ta

Một điểm quan trọng: nếu bạn sử dụng http.DefaultClient (tức là chỉ http.Get() mà không có client rõ ràng), proxy sẽ không được áp dụng. Luôn tạo một http.Client riêng để làm việc với proxy.

💡 Mẹo

Thêm thời gian chờ vào http.Client: Timeout: 30 * time.Second. Các máy chủ proxy có thể phản hồi chậm hơn so với kết nối trực tiếp, và nếu không có thời gian chờ, goroutines sẽ bị treo vô thời hạn.

Proxy qua biến môi trường

Go hỗ trợ các biến môi trường tiêu chuẩn cho proxy — HTTP_PROXY, HTTPS_PROXY và NO_PROXY. Transport tiêu chuẩn http.DefaultTransport tự động đọc chúng thông qua hàm http.ProxyFromEnvironment.

Thiết lập các biến môi trường trước khi chạy ứng dụng:

# Trong terminal (Linux/macOS)
export HTTP_PROXY="http://123.45.67.89:8080"
export HTTPS_PROXY="http://123.45.67.89:8080"
export NO_PROXY="localhost,127.0.0.1"

# Chạy ứng dụng
go run main.go

Nếu bạn muốn sử dụng ProxyFromEnvironment trong transport riêng của mình (ví dụ, với các cấu hình TLS bổ sung), hãy làm như sau:

transport := &http.Transport{
    Proxy: http.ProxyFromEnvironment,
    // Cấu hình bổ sung...
    TLSHandshakeTimeout:   10 * time.Second,
    ResponseHeaderTimeout: 30 * time.Second,
}

client := &http.Client{
    Transport: transport,
    Timeout:   60 * time.Second,
}

Cách tiếp cận này thuận tiện cho các môi trường production, nơi địa chỉ proxy được chỉ định thông qua cấu hình triển khai (Docker, Kubernetes, systemd), thay vì được mã hóa cứng trong mã. Điều này cũng giúp đơn giản hóa việc thay đổi proxy mà không cần biên dịch lại ứng dụng.

Kết nối SOCKS5-proxy trong Golang

SOCKS5 là một giao thức đa năng hơn so với HTTP-proxy. Nó hoạt động ở cấp độ thấp hơn và hỗ trợ bất kỳ kết nối TCP/UDP nào, không chỉ HTTP/HTTPS. Đối với việc làm việc với các trình phân tích và tự động hóa, SOCKS5 thường được ưa chuộng hơn — đặc biệt là khi sử dụng proxy cư trú, thường được cung cấp qua giao thức này.

Để làm việc với SOCKS5 trong Go, cần có gói golang.org/x/net/proxy:

go get golang.org/x/net/proxy

Ví dụ về việc kết nối SOCKS5-proxy mà không cần xác thực:

package main

import (
    "fmt"
    "io"
    "net/http"
    "golang.org/x/net/proxy"
)

func main() {
    // Tạo một SOCKS5 dialer
    dialer, err := proxy.SOCKS5("tcp", "123.45.67.89:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    // Tạo một transport với dialer tùy chỉnh
    transport := &http.Transport{
        Dial: dialer.Dial,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Bắt đầu từ Go 1.20+, bạn cũng có thể sử dụng hỗ trợ SOCKS5 tích hợp thông qua url.Parse với tiền tố socks5://:

proxyURL, _ := url.Parse("socks5://123.45.67.89:1080")

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{Transport: transport}

Cú pháp này đơn giản hơn và không yêu cầu các phụ thuộc bổ sung. Tuy nhiên, cho các kịch bản phức tạp hơn (ví dụ: SOCKS5 với xác thực trong các phiên bản Go cũ), gói golang.org/x/net/proxy vẫn còn phù hợp.

Xác thực: tên đăng nhập và mật khẩu trong proxy

Hầu hết các nhà cung cấp proxy thương mại sử dụng xác thực bằng tên đăng nhập và mật khẩu. Có hai cách để truyền thông tin xác thực trong Go.

Cách 1: Nhúng vào URL

// Định dạng: protocol://username:password@host:port
proxyURL, err := url.Parse("http://myuser:[email protected]:8080")
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

Cách 2: Qua cấu trúc url.URL (an toàn hơn)

proxyURL := &url.URL{
    Scheme: "http",
    Host:   "proxy.example.com:8080",
    User:   url.UserPassword("myuser", "mypassword"),
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

Cách thứ hai được ưu tiên hơn — nó xử lý đúng các ký tự đặc biệt trong mật khẩu (ví dụ: @, #, :), có thể làm hỏng việc phân tích URL trong lựa chọn đầu tiên.

Đối với SOCKS5 với xác thực qua gói golang.org/x/net/proxy:

auth := &proxy.Auth{
    User:     "myuser",
    Password: "mypassword",
}

dialer, err := proxy.SOCKS5("tcp", "proxy.example.com:1080", auth, proxy.Direct)
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Dial: dialer.Dial,
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

⚠️ An toàn

Không bao giờ mã hóa cứng tên đăng nhập và mật khẩu proxy trực tiếp trong mã. Sử dụng các biến môi trường hoặc tệp cấu hình không được đưa vào kho lưu trữ. Thêm .env vào .gitignore.

Xoay vòng proxy: chuyển đổi IP giữa các yêu cầu

Một proxy — là tốt cho việc kiểm tra, nhưng để phân tích thực tế cần có xoay vòng IP. Các trang web theo dõi tần suất yêu cầu từ một địa chỉ, và ngay cả một proxy tốt cũng sẽ bị chặn nếu gửi hàng ngàn yêu cầu liên tiếp qua nó.

Có hai cách tiếp cận cho việc xoay vòng trong Go:

Cách tiếp cận 1: Danh sách proxy với round-robin

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync/atomic"
    "time"
)

type ProxyRotator struct {
    proxies []*url.URL
    counter uint64
}

func NewProxyRotator(proxyURLs []string) (*ProxyRotator, error) {
    proxies := make([]*url.URL, 0, len(proxyURLs))
    for _, p := range proxyURLs {
        u, err := url.Parse(p)
        if err != nil {
            return nil, err
        }
        proxies = append(proxies, u)
    }
    return &ProxyRotator{proxies: proxies}, nil
}

// GetClient trả về client với proxy tiếp theo theo vòng
func (r *ProxyRotator) GetClient() *http.Client {
    idx := atomic.AddUint64(&r.counter, 1) % uint64(len(r.proxies))
    proxyURL := r.proxies[idx]

    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    return &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }
}

func main() {
    proxyList := []string{
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
    }

    rotator, err := NewProxyRotator(proxyList)
    if err != nil {
        panic(err)
    }

    // Mỗi yêu cầu đi qua proxy tiếp theo
    for i := 0; i < 10; i++ {
        client := rotator.GetClient()
        resp, err := client.Get("https://httpbin.org/ip")
        if err != nil {
            fmt.Printf("Lỗi yêu cầu %d: %v\n", i, err)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        fmt.Printf("Yêu cầu %d: %s\n", i, string(body))
    }
}

Cách tiếp cận 2: Lựa chọn proxy động qua hàm

Trường Proxy trong http.Transport nhận một hàm với chữ ký func(*http.Request) (*url.URL, error). Điều này cho phép chọn proxy một cách động cho mỗi yêu cầu:

proxies := []*url.URL{
    mustParseURL("http://proxy1.example.com:8080"),
    mustParseURL("http://proxy2.example.com:8080"),
    mustParseURL("http://proxy3.example.com:8080"),
}

var counter uint64

transport := &http.Transport{
    Proxy: func(req *http.Request) (*url.URL, error) {
        // Chọn proxy dựa trên yêu cầu (round-robin)
        idx := atomic.AddUint64(&counter, 1) % uint64(len(proxies))
        return proxies[idx], nil
    },
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

func mustParseURL(s string) *url.URL {
    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }
    return u
}

Cách tiếp cận thứ hai thanh lịch hơn — một client tự động xoay vòng proxy cho mỗi yêu cầu. Điều này đặc biệt thuận tiện khi có nhiều yêu cầu đồng thời qua goroutines.

Loại proxy nào nên chọn cho dự án Go

Việc chọn loại proxy ảnh hưởng trực tiếp đến thành công của dự án của bạn. Đối với các nhiệm vụ khác nhau, các loại khác nhau sẽ phù hợp — chúng ta sẽ xem xét các tùy chọn chính:

Loại proxy	Tốc độ	Ẩn danh	Tốt nhất cho
Data-center	⚡ Cao	Trung bình	Phân tích dữ liệu mở, kiểm tra API, kiểm tra tải
Cư trú	🔄 Trung bình	Cao	Phân tích các thị trường trực tuyến (Wildberries, Ozon), vượt qua bảo vệ chống bot
Di động	🔄 Trung bình	Tối đa	Làm việc với mạng xã hội, dịch vụ có bảo vệ chống bot nghiêm ngặt

Đối với việc phân tích các thị trường trực tuyến (Wildberries, Ozon, Avito): hãy sử dụng proxy cư trú. Những nền tảng này thường sử dụng các hệ thống phát hiện bot (Cloudflare, giải pháp riêng) và dễ dàng chặn IP của các trung tâm dữ liệu. IP cư trú trông giống như người dùng thông thường tại nhà.

Đối với việc kiểm tra API và kiểm tra tải: proxy trung tâm dữ liệu là lựa chọn tối ưu. Tốc độ cao, kết nối ổn định, độ trễ dự đoán được.

Đối với kiểm tra địa lý: proxy cư trú với lựa chọn quốc gia/thành phố. Cho phép kiểm tra cách dịch vụ hoặc quảng cáo của bạn xuất hiện đối với người dùng từ một khu vực cụ thể.

Những lỗi thường gặp và các thực tiễn tốt nhất

Trong nhiều năm làm việc với proxy trong các dự án Go, đã hình thành danh sách các lỗi điển hình, làm chậm quá trình phát triển và giảm độ tin cậy của các trình phân tích. Chúng ta sẽ xem xét từng lỗi.

Lỗi 1: Tái sử dụng transport mà không đặt lại kết nối

http.Transport lưu trữ các kết nối TCP (keep-alive). Nếu bạn tạo một transport mới cho mỗi yêu cầu, bạn sẽ mất lợi thế này. Nhưng nếu tái sử dụng một transport với proxy cố định khi xoay vòng — các yêu cầu có thể đi qua kết nối cũ, bỏ qua proxy mới.

Giải pháp: khi thay đổi proxy, hãy gọi transport.CloseIdleConnections() hoặc sử dụng cách tiếp cận chức năng với việc chọn proxy động (được mô tả trong phần về xoay vòng).

Lỗi 2: Không xử lý lỗi proxy

Proxy có thể không khả dụng, quá tải hoặc bị chặn bởi trang web mục tiêu. Nếu không có logic retry, trình phân tích của bạn sẽ dừng lại ngay khi gặp lỗi đầu tiên.

func fetchWithRetry(client *http.Client, targetURL string, maxRetries int) ([]byte, error) {
    var lastErr error
    for i := 0; i < maxRetries; i++ {
        resp, err := client.Get(targetURL)
        if err != nil {
            lastErr = err
            time.Sleep(time.Duration(i+1) * time.Second) // Độ trễ theo cấp số nhân
            continue
        }
        defer resp.Body.Close()

        if resp.StatusCode == 429 || resp.StatusCode == 403 {
            lastErr = fmt.Errorf("bị chặn: trạng thái %d", resp.StatusCode)
            time.Sleep(time.Duration(i+1) * 2 * time.Second)
            continue
        }

        return io.ReadAll(resp.Body)
    }
    return nil, fmt.Errorf("tất cả các lần thử đã hết: %w", lastErr)
}

Lỗi 3: Bỏ qua xác thực TLS

Một số nhà phát triển tắt xác thực chứng chỉ TLS cho proxy (InsecureSkipVerify: true). Điều này tạo ra lỗ hổng cho các cuộc tấn công MITM. Nếu máy chủ proxy sử dụng chứng chỉ tự ký — hãy thêm nó vào nhóm tin cậy, thay vì tắt xác thực hoàn toàn.

Lỗi 4: Các tiêu đề giống nhau cho tất cả các yêu cầu

Ngay cả với việc xoay vòng proxy, bạn có thể bị chặn theo mẫu tiêu đề. Thay đổi User-Agent cùng với proxy, thêm các tiêu đề trình duyệt thực tế:

userAgents := []string{
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/119.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/118.0.0.0 Safari/537.36",
}

req, _ := http.NewRequest("GET", targetURL, nil)
req.Header.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
req.Header.Set("Accept-Language", "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7")
req.Header.Set("Accept-Encoding", "gzip, deflate, br")

Danh sách kiểm tra cho một client proxy đáng tin cậy trong Go

✅ Thời gian chờ trên client (Timeout: 30 * time.Second)
✅ Logic retry với độ trễ theo cấp số nhân
✅ Xoay vòng proxy khi gặp lỗi 403/429
✅ Xoay vòng User-Agent cùng với proxy
✅ Ghi lại lỗi với thông tin về proxy đã sử dụng
✅ Thông tin xác thực qua biến môi trường, không mã hóa cứng
✅ Đóng resp.Body qua defer
✅ Giới hạn độ cạnh tranh qua semaphore hoặc worker pool

Ví dụ về một worker pool hoàn chỉnh với xoay vòng proxy

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync"
    "sync/atomic"
    "time"
)

type Scraper struct {
    proxies []*url.URL
    counter uint64
    workers int
}

func (s *Scraper) getClient() *http.Client {
    idx := atomic.AddUint64(&s.counter, 1) % uint64(len(s.proxies))
    return &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(s.proxies[idx]),
        },
        Timeout: 30 * time.Second,
    }
}

func (s *Scraper) Scrape(urls []string) map[string]string {
    results := make(map[string]string)
    var mu sync.Mutex
    var wg sync.WaitGroup

    sem := make(chan struct{}, s.workers) // Semaphore để giới hạn độ cạnh tranh

    for _, u := range urls {
        wg.Add(1)
        go func(targetURL string) {
            defer wg.Done()
            sem <- struct{}{}
            defer func() { <-sem }()

            client := s.getClient()
            resp, err := client.Get(targetURL)
            if err != nil {
                fmt.Printf("Lỗi: %v\n", err)
                return
            }
            defer resp.Body.Close()

            body, _ := io.ReadAll(resp.Body)

            mu.Lock()
            results[targetURL] = string(body)
            mu.Unlock()
        }(u)
    }

    wg.Wait()
    return results
}

Kết luận

Cấu hình proxy trong Go — là một nhiệm vụ có thể giải quyết bằng vài dòng mã, nhưng đòi hỏi hiểu biết về các chi tiết: cách sử dụng đúng http.Transport, xử lý xác thực chính xác, xoay vòng IP hợp lý và xử lý lỗi. Thư viện tiêu chuẩn cung cấp mọi thứ cần thiết cho HTTP-proxy, trong khi gói golang.org/x/net/proxy đáp ứng nhu cầu về SOCKS5.

Những điểm chính từ bài viết:

Luôn tạo một http.Client riêng — http.DefaultClient không hỗ trợ proxy trực tiếp
Sử dụng cách tiếp cận chức năng (Proxy: func(r *Request) (*url.URL, error)) cho việc xoay vòng động
Lưu trữ thông tin xác thực trong biến môi trường, không trong mã
Thêm logic retry — proxy không bao giờ hoàn toàn đáng tin cậy
Thay đổi User-Agent cùng với proxy để đạt hiệu quả tối đa

Nếu bạn đang viết một trình phân tích cho các thị trường trực tuyến như Wildberries hoặc Ozon, chúng tôi khuyên bạn nên sử dụng proxy cư trú — chúng có IP thực của người dùng tại nhà và hiếm khi bị chặn bởi các hệ thống chống bot. Đối với các kịch bản có tải cao với hàng ngàn yêu cầu mỗi phút, lựa chọn tối ưu sẽ là proxy trung tâm dữ liệu — chúng cung cấp tốc độ tối đa và độ ổn định của kết nối.