HTTP/2 Go-യുടെ SOCKS ടണലിനുള്ളിൽ ഒതുങ്ങുന്നു

ഒരു SOCKS ടണൽ ഒരു TCP കണക്ഷൻ വഹിക്കുന്നു. ആ ടണലിലൂടെ Go-ക്ക് ലക്ഷ്യവുമായി TLS നടത്താനും അവിടെ HTTP/2 ചർച്ച ചെയ്യാനും കഴിയും; SOCKS സെർവർ തന്നെ HTTP/2 സംസാരിക്കേണ്ടതില്ല.

Go-യുടെ സ്റ്റാൻഡേർഡ് ഡിഫോൾട്ട് ട്രാൻസ്പോർട്ട് നിലനിർത്തുന്ന ഒരു പ്രോഗ്രാമിൽ, അതിന്റെ കോൺഫിഗറേഷൻ ക്ലോൺ ചെയ്ത് പ്രോക്സി തിരഞ്ഞെടുക്കുക:

import (
    "net/http"
    "net/url"
    "time"
)

proxyURL := &url.URL{
    Scheme: "socks5",
    Host: "proxy.example:1080",
}
transport := http.DefaultTransport.(*http.Transport).Clone()
transport.Proxy = http.ProxyURL(proxyURL)
client := &http.Client{
    Transport: transport,
    Timeout: 30 * time.Second,
}

പ്രോക്സിയും ലക്ഷ്യവും വ്യത്യസ്ത മൂല്യങ്ങളായി തുടരുന്നു. പ്രോക്സി മൂല്യത്തിനായി SOCKS5 പ്രോക്സി പട്ടികയിൽ നിന്ന് ഒരു SOCKS5 എൻഡ്പോയിന്റ് തിരഞ്ഞെടുക്കുക; HTTP/2 ഇപ്പോഴും ലക്ഷ്യവുമായി ചർച്ച ചെയ്യപ്പെടുന്നു. യഥാർത്ഥ HTTPS സേവന URL അഭ്യർത്ഥിക്കാൻ client ഉപയോഗിക്കുക, തുടർന്ന് ആപ്ലിക്കേഷന്റെ സാധാരണ ലൈഫ് സൈക്കിളിലൂടെ പ്രതികരണ ബോഡി അടയ്ക്കുക.

സ്റ്റാൻഡേർഡ് ഡിഫോൾട്ട് ട്രാൻസ്പോർട്ട് HTTP/2 പിന്തുണയ്ക്കുന്നു. അത് ക്ലോൺ ചെയ്യുന്നത് ആ കോൺഫിഗറേഷൻ നിലനിർത്തുകയും പ്രോക്സി തിരഞ്ഞെടുപ്പ് മാറ്റാൻ അനുവദിക്കുകയും ചെയ്യുന്നു. ടൈപ്പ് അസർഷൻ പ്രോഗ്രാം http.DefaultTransport മറ്റൊരു RoundTripper ഉപയോഗിച്ച് മാറ്റിയിട്ടില്ലെന്ന് അനുമാനിക്കുന്നു.

വേർതിരിച്ച് നിർമ്മിച്ച ട്രാൻസ്പോർട്ടിന്, അതിന്റെ HTTP/2 കോൺഫിഗറേഷൻ പരിശോധിക്കുക, പ്രത്യേകിച്ച് ഇഷ്ടാനുസൃത dial അല്ലെങ്കിൽ TLS ഹുക്കുകൾ നൽകുമ്പോൾ. Go ForceAttemptHTTP2-ഉം പുതിയ റിലീസുകളിൽ ആ തിരഞ്ഞെടുപ്പുകൾക്കായി വ്യക്തമായ Protocols കോൺഫിഗറേഷനും വെളിപ്പെടുത്തുന്നു.

ലക്ഷ്യം ഇപ്പോഴും TLS ചർച്ചയിലൂടെ HTTP/2 വാഗ്ദാനം ചെയ്യണം. എന്താണ് ഉപയോഗിച്ചതെന്ന് കാണാൻ വിജയകരമായ പ്രതികരണത്തിന്റെ Proto അല്ലെങ്കിൽ ProtoMajor മൂല്യം പരിശോധിക്കുക. SOCKS വഴി വിജയിക്കുന്ന HTTPS അഭ്യർത്ഥന അതിൽത്തന്നെ ചർച്ച ചെയ്ത പ്രോട്ടോക്കോൾ HTTP/2 ആയിരുന്നുവെന്ന് തെളിയിക്കുന്നില്ല.