Прокси в Go: настройка http.Client с прокси-сервером

Если вы пишете парсер, автоматизируете сбор данных или тестируете API из разных регионов — рано или поздно столкнётесь с блокировками по IP. Go — один из самых популярных языков для написания высокопроизводительных сетевых инструментов, и настройка прокси здесь имеет свои особенности. В этом руководстве разберём всё от базовой конфигурации http.Client до продвинутой ротации IP с поддержкой SOCKS5.

Зачем нужны прокси в Go-приложениях

Go стал стандартом де-факто для написания высоконагруженных сетевых инструментов: парсеров, краулеров, ботов для мониторинга цен, инструментов автоматизации API. Именно здесь потребность в прокси возникает чаще всего — и именно здесь важно настроить всё правильно с самого начала.

Основные сценарии, когда без прокси не обойтись:

Парсинг маркетплейсов — Wildberries, Ozon, AliExpress блокируют IP после 50–200 запросов с одного адреса. Без смены IP парсер останавливается.
Гео-тестирование — проверка выдачи поисковиков, рекламных объявлений или цен из разных стран и регионов.
Обход rate-limit — распределение нагрузки по нескольким IP позволяет обойти ограничения на количество запросов в минуту.
Анонимность — скрытие реального IP сервера при работе с внешними API.
Тестирование CDN и геолокации — проверка корректности отдачи контента для разных регионов.

Стандартная библиотека Go предоставляет гибкие инструменты для работы с прокси — через http.Transport и http.Client. Разберём каждый способ подробно.

Базовая настройка HTTP-прокси через http.Client

В Go прокси настраивается на уровне http.Transport — транспортного слоя HTTP-клиента. Это даёт полный контроль над тем, через какой прокси идут запросы, и позволяет создавать несколько клиентов с разными прокси одновременно.

Минимальный рабочий пример настройки HTTP-прокси:

package main

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

func main() {
    // Указываем адрес прокси-сервера
    proxyURL, err := url.Parse("http://123.45.67.89:8080")
    if err != nil {
        panic(err)
    }

    // Создаём транспорт с прокси
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    // Создаём клиент с нашим транспортом
    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))
}

Что происходит в этом коде:

url.Parse — парсит строку с адресом прокси в структуру *url.URL
http.Transport{Proxy: http.ProxyURL(proxyURL)} — создаёт транспорт, который направляет все запросы через указанный прокси
http.Client{Transport: transport} — создаёт клиент с нашим транспортом

Важный момент: если вы используете http.DefaultClient (то есть просто http.Get() без явного клиента), прокси применён не будет. Всегда создавайте собственный http.Client для работы с прокси.

💡 Совет

Добавьте таймаут в http.Client: Timeout: 30 * time.Second. Прокси-серверы могут отвечать медленнее, чем прямое соединение, и без таймаута горутины будут зависать бесконечно.

Прокси через переменные окружения

Go поддерживает стандартные переменные окружения для прокси — HTTP_PROXY, HTTPS_PROXY и NO_PROXY. Стандартный транспорт http.DefaultTransport читает их автоматически через функцию http.ProxyFromEnvironment.

Установка переменных окружения перед запуском приложения:

# В терминале (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"

# Запускаем приложение
go run main.go

Если вы хотите использовать ProxyFromEnvironment в собственном транспорте (например, с дополнительными настройками TLS), сделайте так:

transport := &http.Transport{
    Proxy: http.ProxyFromEnvironment,
    // Дополнительные настройки...
    TLSHandshakeTimeout:   10 * time.Second,
    ResponseHeaderTimeout: 30 * time.Second,
}

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

Этот подход удобен для production-окружений, где адрес прокси задаётся через конфигурацию деплоя (Docker, Kubernetes, systemd), а не хардкодится в коде. Также это упрощает смену прокси без перекомпиляции приложения.

Подключение SOCKS5-прокси в Golang

SOCKS5 — более универсальный протокол по сравнению с HTTP-прокси. Он работает на более низком уровне и поддерживает любые TCP/UDP соединения, а не только HTTP/HTTPS. Для работы с парсерами и автоматизацией SOCKS5 часто предпочтительнее — особенно при использовании резидентных прокси, которые чаще всего предоставляются именно по этому протоколу.

Для работы с SOCKS5 в Go нужен пакет golang.org/x/net/proxy:

go get golang.org/x/net/proxy

Пример подключения SOCKS5-прокси без аутентификации:

package main

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

func main() {
    // Создаём SOCKS5 dialer
    dialer, err := proxy.SOCKS5("tcp", "123.45.67.89:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    // Создаём транспорт с кастомным dialer
    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))
}

Начиная с Go 1.20+ можно также использовать встроенную поддержку SOCKS5 через url.Parse с префиксом socks5://:

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

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

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

Этот синтаксис проще и не требует дополнительных зависимостей. Однако для более сложных сценариев (например, SOCKS5 с аутентификацией в старых версиях Go) пакет golang.org/x/net/proxy остаётся актуальным.

Аутентификация: логин и пароль в прокси

Большинство коммерческих прокси-провайдеров используют аутентификацию по логину и паролю. Существует два способа передачи учётных данных в Go.

Способ 1: Встроить в URL

// Формат: 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,
}

Способ 2: Через структуру url.URL (более безопасно)

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,
}

Второй способ предпочтительнее — он корректно обрабатывает специальные символы в пароле (например, @, #, :), которые могут сломать парсинг URL в первом варианте.

Для SOCKS5 с аутентификацией через пакет 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,
}

⚠️ Безопасность

Никогда не хардкодьте логин и пароль прокси прямо в коде. Используйте переменные окружения или конфигурационные файлы, которые не попадают в репозиторий. Добавьте .env в .gitignore.

Ротация прокси: переключение IP между запросами

Один прокси — это хорошо для тестирования, но для реального парсинга нужна ротация IP. Сайты отслеживают частоту запросов с одного адреса, и даже хороший прокси заблокируют, если слать через него тысячи запросов подряд.

Есть два подхода к ротации в Go:

Подход 1: Список прокси с 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 возвращает клиент со следующим прокси по кругу
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)
    }

    // Каждый запрос идёт через следующий прокси
    for i := 0; i < 10; i++ {
        client := rotator.GetClient()
        resp, err := client.Get("https://httpbin.org/ip")
        if err != nil {
            fmt.Printf("Ошибка запроса %d: %v\n", i, err)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        fmt.Printf("Запрос %d: %s\n", i, string(body))
    }
}

Подход 2: Динамический выбор прокси через функцию

Поле Proxy в http.Transport принимает функцию с сигнатурой func(*http.Request) (*url.URL, error). Это позволяет выбирать прокси динамически для каждого запроса:

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) {
        // Выбираем прокси на основе запроса (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
}

Второй подход элегантнее — один клиент автоматически ротирует прокси для каждого запроса. Это особенно удобно при конкурентных запросах через горутины.

Какой тип прокси выбрать для Go-проекта

Выбор типа прокси напрямую влияет на успех вашего проекта. Для разных задач подходят разные типы — разберём основные варианты:

Тип прокси	Скорость	Анонимность	Лучше всего для
Дата-центр	⚡ Высокая	Средняя	Парсинг открытых данных, тестирование API, нагрузочное тестирование
Резидентные	🔄 Средняя	Высокая	Парсинг маркетплейсов (Wildberries, Ozon), обход антибот-защиты
Мобильные	🔄 Средняя	Максимальная	Работа с соцсетями, сервисами с жёсткой антибот-защитой

Для парсинга маркетплейсов (Wildberries, Ozon, Авито): используйте резидентные прокси. Эти платформы активно используют системы обнаружения ботов (Cloudflare, собственные решения) и легко блокируют IP дата-центров. Резидентные IP выглядят как обычные домашние пользователи.

Для тестирования API и нагрузочного тестирования: прокси дата-центров — оптимальный выбор. Высокая скорость, стабильное соединение, предсказуемая задержка.

Для гео-тестирования: резидентные прокси с выбором страны/города. Позволяют проверить, как ваш сервис или реклама выглядит для пользователей из конкретного региона.

Частые ошибки и лучшие практики

За годы работы с прокси в Go-проектах выкристаллизовался список типичных ошибок, которые замедляют разработку и снижают надёжность парсеров. Разберём каждую.

Ошибка 1: Переиспользование транспорта без сброса соединений

http.Transport кэширует TCP-соединения (keep-alive). Если вы создаёте новый транспорт для каждого запроса, вы теряете это преимущество. Но если переиспользуете один транспорт с фиксированным прокси при ротации — запросы могут идти через старое соединение, минуя новый прокси.

Решение: при смене прокси вызывайте transport.CloseIdleConnections() или используйте функциональный подход с динамическим выбором прокси (описан в разделе про ротацию).

Ошибка 2: Нет обработки ошибок прокси

Прокси могут быть недоступны, перегружены или заблокированы целевым сайтом. Без retry-логики ваш парсер остановится на первой же ошибке.

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) // Экспоненциальная задержка
            continue
        }
        defer resp.Body.Close()

        if resp.StatusCode == 429 || resp.StatusCode == 403 {
            lastErr = fmt.Errorf("заблокирован: статус %d", resp.StatusCode)
            time.Sleep(time.Duration(i+1) * 2 * time.Second)
            continue
        }

        return io.ReadAll(resp.Body)
    }
    return nil, fmt.Errorf("все попытки исчерпаны: %w", lastErr)
}

Ошибка 3: Игнорирование TLS-верификации

Некоторые разработчики отключают верификацию TLS-сертификатов для прокси (InsecureSkipVerify: true). Это создаёт уязвимость для MITM-атак. Если прокси-сервер использует самоподписанный сертификат — добавьте его в пул доверенных, а не отключайте верификацию полностью.

Ошибка 4: Одинаковые заголовки для всех запросов

Даже с ротацией прокси вас могут заблокировать по паттерну заголовков. Меняйте User-Agent вместе с прокси, добавляйте реалистичные заголовки браузера:

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")

Чек-лист надёжного прокси-клиента в Go

✅ Таймаут на клиенте (Timeout: 30 * time.Second)
✅ Retry-логика с экспоненциальной задержкой
✅ Ротация прокси при ошибках 403/429
✅ Ротация User-Agent вместе с прокси
✅ Логирование ошибок с указанием использованного прокси
✅ Учётные данные через переменные окружения, не хардкод
✅ Закрытие resp.Body через defer
✅ Ограничение конкурентности через семафор или worker pool

Пример полноценного worker pool с ротацией прокси

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) // Семафор для ограничения конкурентности

    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("Ошибка: %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
}

Заключение

Настройка прокси в Go — задача, которая решается несколькими строками кода, но требует понимания нюансов: правильного использования http.Transport, корректной обработки аутентификации, грамотной ротации IP и обработки ошибок. Стандартная библиотека предоставляет всё необходимое для HTTP-прокси, а пакет golang.org/x/net/proxy закрывает потребность в SOCKS5.

Ключевые выводы из статьи:

Всегда создавайте собственный http.Client — http.DefaultClient не поддерживает прокси напрямую
Используйте функциональный подход (Proxy: func(r *Request) (*url.URL, error)) для динамической ротации
Храните учётные данные в переменных окружения, не в коде
Добавляйте retry-логику — прокси не бывают на 100% надёжными
Меняйте User-Agent вместе с прокси для максимальной эффективности

Если вы пишете парсер для маркетплейсов вроде Wildberries или Ozon, рекомендуем использовать резидентные прокси — они имеют реальные IP домашних пользователей и значительно реже попадают под блокировки антибот-систем. Для высоконагруженных сценариев с тысячами запросов в минуту оптимальным выбором станут прокси дата-центров — они обеспечивают максимальную скорость и стабильность соединения.