Go HTTP ക്ലയന്റിന് സ്വന്തം പ്രോക്സി നൽകുക

Go HTTP ക്ലയന്റിന്റെ transport ആണ് പ്രോക്സി തിരഞ്ഞെടുക്കുന്നത്. ഡിഫോൾട്ട് ക്ലയന്റിന്റെ മറ്റ് ഉപയോക്താക്കൾക്ക് നിലവിലെ റൂട്ടിങ് നിലനിർത്താൻ, സ്റ്റാൻഡേർഡ് transport മാറ്റുന്നതിനുമുമ്പ് ക്ലോൺ ചെയ്യുക.

package main

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

func main() {
    proxyURL, err := url.Parse("http://203.0.113.10:8080")
    if err != nil {
        log.Fatal(err)
    }

    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxyURL)
    defer transport.CloseIdleConnections()

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

    response, err := client.Get("https://example.com/")
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    fmt.Println(response.StatusCode)
    if _, err := io.Copy(io.Discard, response.Body); err != nil {
        log.Fatal(err)
    }
}

വിലാസം രേഖകളിലെ ഉദാഹരണമാണ്. HTTP പ്രോക്സി പട്ടികയിൽനിന്ന് തിരഞ്ഞെടുത്തത് പോലുള്ള യഥാർഥ HTTP പ്രോക്സിയുടെ IP-യും പോർട്ടും പകരം നൽകുക. ഉദാഹരണം Go-യുടെ സ്റ്റാൻഡേർഡ് ലൈബ്രറി മാത്രമാണ് ഉപയോഗിക്കുന്നത്; ഈ HTTP പ്രോക്സി അഭ്യർഥനയ്ക്ക് SOCKS പാക്കേജോ പ്രോസസ് മുഴുവനുമുള്ള എൻവയൺമെന്റ് വേരിയബിളോ വേണ്ട.

DefaultTransport നേരിട്ട് മാറ്റാത്തതെന്തുകൊണ്ട്?

ഡിഫോൾട്ട് transport പങ്കിടപ്പെടുന്നതാണ്. അത് മാറ്റുന്നത് നിങ്ങളുടെ പ്രോക്സി ആവശ്യപ്പെടാത്ത കോഡിന്റെ പ്രവർത്തനത്തെയും ബാധിക്കാം. അഭ്യർഥനകൾ ഉപയോഗിക്കുന്നതിനിടെ മാറ്റുന്നത് ഒഴിവാക്കാവുന്ന സമാന്തരപ്രവർത്തന പ്രശ്നങ്ങളും ഉണ്ടാക്കും. സ്വന്തം transport റൂട്ടിനെ ഈ ക്ലയന്റിന്റെ ക്രമീകരണത്തിന്റെ ഭാഗമാക്കുന്നു.

http.ProxyURL നൽകിയ URL എപ്പോഴും തിരഞ്ഞെടുക്കുന്ന സെലക്ടർ തിരികെ നൽകുന്നു. പ്രോക്സി വേരിയബിളുകളും ബൈപാസ് ചട്ടങ്ങളും പരിഗണിക്കുന്ന ഡിഫോൾട്ട് എൻവയൺമെന്റ് സെലക്ടറിൽനിന്ന് ഇതു വ്യത്യസ്തമാണ്. HTTP പട്ടികയിലെ ഒരു പ്രത്യേക എൻട്രി പരിശോധിക്കുകയാണ് ഉദ്ദേശ്യമെങ്കിൽ വ്യക്തമായ സെലക്ടർ ഈ അവ്യക്തത ഒഴിവാക്കും.

പ്രതികരണം അടച്ച് ക്ലയന്റ് വീണ്ടും ഉപയോഗിക്കുക

ഉദാഹരണം പ്രതികരണത്തിന്റെ ബോഡി മുഴുവനായി വായിച്ച് അടയ്ക്കുന്നു. അവസാനംവരെ വായിക്കുന്നത് സാധ്യമാകുമ്പോൾ കണക്ഷൻ വീണ്ടും ഉപയോഗിക്കാൻ transport-നെ സഹായിക്കുന്നു. ഒരേ പ്രോക്സിയിലൂടെ പല അഭ്യർഥനകൾ ചെയ്യുന്ന പ്രോഗ്രാമിൽ ഓരോ തവണയും പുതിയ ജോഡി സൃഷ്ടിക്കാതെ ക്ലയന്റും transport-ഉം നിലനിർത്തുക.

ക്ലയന്റിന്റെ സമയപരിധി സോക്കറ്റ് തുറക്കുന്നതിൽ ഒതുങ്ങുന്നില്ല; പ്രതികരണ ബോഡി വായിക്കുന്നതടക്കമുള്ള അഭ്യർഥനയുടെ ജീവിതചക്രത്തെയും നിയന്ത്രിക്കുന്നു. Get മടങ്ങിയശേഷവും വായനപ്പിശകുകൾ കൈകാര്യം ചെയ്യണം. 403 പോലുള്ള സ്റ്റാറ്റസ് Go transport പിശകല്ല; അതിനാൽ StatusCode, err എന്നിവ വേർതിരിച്ച് പരിശോധിക്കുക.