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 ಆಗಿತ್ತು ಎಂದು ಸಾಬೀತುಪಡಿಸುವುದಿಲ್ಲ.