프록시를 Go에서 사용하기: 프록시 서버로 http.Client 설정하기

```html

파서를 작성하거나 데이터를 자동으로 수집하거나 다양한 지역의 API를 테스트하는 경우 — 언젠가는 IP 차단에 직면하게 됩니다. Go는 고성능 네트워크 도구를 작성하는 데 가장 인기 있는 언어 중 하나이며, 여기서 프록시 설정은 고유한 특성이 있습니다. 이 가이드에서는 기본 구성 http.Client에서 SOCKS5 지원을 포함한 고급 IP 회전까지 모든 것을 다룹니다.

Go 애플리케이션에서 프록시가 필요한 이유

Go는 고부하 네트워크 도구를 작성하는 데 사실상의 표준이 되었습니다: 파서, 크롤러, 가격 모니터링 봇, API 자동화 도구. 여기서 프록시의 필요성이 가장 자주 발생하며, 처음부터 모든 것을 올바르게 설정하는 것이 중요합니다.

프록시 없이는 불가능한 주요 시나리오는 다음과 같습니다:

마켓플레이스 파싱 — Wildberries, Ozon, AliExpress는 하나의 주소에서 50–200개의 요청 후 IP를 차단합니다. IP를 변경하지 않으면 파서가 중단됩니다.
지리적 테스트 — 다양한 국가 및 지역의 검색 엔진 결과, 광고 또는 가격 확인.
요청 속도 제한 우회 — 여러 IP에 부하를 분산하여 분당 요청 수에 대한 제한을 우회할 수 있습니다.
익명성 — 외부 API와 작업할 때 실제 서버 IP 숨기기.
CDN 및 지리적 위치 테스트 — 다양한 지역에 대한 콘텐츠 제공의 정확성 확인.

Go의 표준 라이브러리는 http.Transport 및 http.Client를 통해 프록시 작업을 위한 유연한 도구를 제공합니다. 각 방법을 자세히 살펴보겠습니다.

http.Client를 통한 HTTP 프록시 기본 설정

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

추가 TLS 설정과 함께 ProxyFromEnvironment를 사용하려면 다음과 같이 하세요:

transport := &http.Transport{
    Proxy: http.ProxyFromEnvironment,
    // 추가 설정...
    TLSHandshakeTimeout:   10 * time.Second,
    ResponseHeaderTimeout: 30 * time.Second,
}

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

이 접근 방식은 프록시 주소가 배포 구성(Docker, Kubernetes, systemd)을 통해 설정되고 코드에 하드코딩되지 않는 production 환경에 유용합니다. 또한 애플리케이션을 재컴파일하지 않고도 프록시를 변경할 수 있습니다.

Golang에서 SOCKS5 프록시 연결하기

SOCKS5는 HTTP 프록시보다 더 범용적인 프로토콜입니다. 더 낮은 수준에서 작동하며 HTTP/HTTPS뿐만 아니라 모든 TCP/UDP 연결을 지원합니다. 파서 및 자동화 작업을 위해 SOCKS5가 더 선호되는 경우가 많습니다 — 특히 주거용 프록시를 사용할 때, 이는 대부분 이 프로토콜을 통해 제공됩니다.

Go에서 SOCKS5를 사용하려면 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, err := proxy.SOCKS5("tcp", "123.45.67.89:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    // 커스텀 다이얼러와 함께 전송 생성
    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+부터는 url.Parse를 통해 socks5:// 접두사를 사용하여 SOCKS5에 대한 내장 지원을 사용할 수 있습니다:

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

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

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

이 구문은 더 간단하며 추가 종속성이 필요하지 않습니다. 그러나 더 복잡한 시나리오(예: 이전 버전의 Go에서 인증이 있는 SOCKS5)의 경우 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: 라운드 로빈으로 프록시 목록 사용하기

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: 함수로 동적으로 프록시 선택하기

http.Transport의 Proxy 필드는 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) {
        // 요청에 따라 프록시 선택 (라운드 로빈)
        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, Avito): 주거용 프록시를 사용하세요. 이러한 플랫폼은 봇 탐지 시스템(Cloudflare, 자체 솔루션)을 적극적으로 사용하며 데이터 센터 IP를 쉽게 차단합니다. 주거용 IP는 일반 가정 사용자처럼 보입니다.

API 테스트 및 부하 테스트를 위한 경우: 데이터 센터 프록시가 최적의 선택입니다. 높은 속도, 안정적인 연결, 예측 가능한 지연.

지리적 테스트를 위한 경우: 국가/도시 선택이 가능한 주거용 프록시. 특정 지역의 사용자에게 서비스나 광고가 어떻게 보이는지 확인할 수 있습니다.

자주 발생하는 오류 및 모범 사례

Go 프로젝트에서 프록시와 함께 작업하면서 발생하는 일반적인 오류 목록이 정리되었습니다. 이러한 오류는 개발 속도를 늦추고 파서의 신뢰성을 저하시킵니다. 각 오류를 살펴보겠습니다.

오류 1: 연결을 재사용할 때 전송을 초기화하지 않음

http.Transport는 TCP 연결을 캐시합니다 (keep-alive). 각 요청마다 새로운 전송을 생성하면 이 장점을 잃게 됩니다. 그러나 고정된 프록시와 함께 하나의 전송을 재사용하면 요청이 이전 연결을 통해 진행되어 새로운 프록시를 우회할 수 있습니다.

해결책: 프록시를 변경할 때 transport.CloseIdleConnections()를 호출하거나 회전에 대한 동적 선택 기능적 접근 방식을 사용하세요 (회전 섹션에서 설명).

오류 2: 프록시 오류 처리 없음

프록시는 사용할 수 없거나 과부하가 걸리거나 대상 사이트에 의해 차단될 수 있습니다. 재시도 로직 없이 파서는 첫 번째 오류에서 중단됩니다.

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)
✅ 지수 대기 재시도 로직
✅ 403/429 오류 시 프록시 회전
✅ 프록시와 함께 User-Agent 회전
✅ 사용된 프록시를 명시한 오류 로깅
✅ 하드코딩하지 않고 환경 변수를 통한 자격 증명
✅ resp.Body를 defer를 통해 닫기
✅ 세마포어 또는 작업자 풀을 통한 동시성 제한

프록시 회전이 포함된 완전한 작업자 풀 예제

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))
자격 증명을 코드에 하드코딩하지 말고 환경 변수에 저장하세요.
재시도 로직을 추가하세요 — 프록시는 100% 신뢰할 수 없습니다.
최대 효율성을 위해 프록시와 함께 User-Agent를 변경하세요.

Wildberries나 Ozon과 같은 마켓플레이스를 위한 파서를 작성하는 경우, 주거용 프록시를 사용하는 것을 권장합니다 — 이들은 실제 가정 사용자의 IP를 가지고 있으며, 봇 방지 시스템에 의해 차단될 확률이 훨씬 낮습니다. 수천 개의 요청을 처리하는 고부하 시나리오에는 데이터 센터 프록시가 최적의 선택입니다 — 이들은 최대 속도와 안정적인 연결을 제공합니다.