Proxies Coupons > 代理指南 & 资讯 > 代理 > 如何在 Go 语言中设置代理
Go 语言中设置代理

如何在 Go 语言中设置代理

Rate this post

代理对于各种网络操作至关重要，例如访问受限内容、增强隐私和调试网络流量。全球代理市场在过去几年中显着增长，使其成为现代软件生态系统的重要组成部分。

Go 中的代理配置概述

Go 通过其标准库和附加包支持代理配置。例如，Go 的标准库包含 net/http 包，它提供了对代理配置的内置支持。此外，SOCKS、goproxy、oxy 和 NTML 等第三方包可用于定义更高级的代理配置。

这是使用标准库设置代理的基本示例：

package main

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

func main() {
    proxyURL, _ := url.Parse("http://your-proxy-url:port")
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }
    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("http://example.com")
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()
    // process response
}

为 HTTP 客户端设置代理

HTTP 代理旨在处理 HTTP 流量，使其成为基于 Web 的应用程序的理想选择。它们可以解释和管理 HTTP 请求和响应，从而实现 URL 过滤、内容缓存和负载平衡等功能。此外，它们还处理特定的 HTTP 标头和方法，提供对 Web 请求的细粒度控制。

在本节中，我们将向您展示如何使用Go 的 net/http 包设置 HTTP 代理，然后将其与 HTTPS 和 SOCKS 代理配置进行比较。

在 go 中设置代理

第1步：创建代理函数

首先，您需要定义一个返回代理 URL 的函数。HTTP 客户端的传输层将使用此函数通过代理路由请求。

func ProxyFunc(req *http.Request) (*url.URL, error) {
    return url.Parse("http://your-proxy-server.com:8080")
}

步骤2：配置HTTP客户端的传输层

接下来，创建一个自定义http transport对象并将 Proxy 字段设置为代理函数：

transport := &http.Transport{
    Proxy: ProxyFunc,
}

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

现在，使用此客户端发出的任何请求都将通过指定的代理服务器进行路由。

这是一个完整的示例：

package main

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

func ProxyFunc(req *http.Request) (*url.URL, error) {
    return url.Parse("http://your-proxy-server.com:8080") // Parsing the proxy URL
}

func main() {
    transport := &http.Transport{ // Creating a new Transport object
        Proxy: ProxyFunc,  //  Setting the transport objects Proxy field to the parsed proxy URL
    }

    client := &http.Client{ // Create a new http.Client instance with the configured transport
        Transport: transport,
    }

    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

步骤 3：定义自定义代理函数

有时，您可能需要更多地控制代理哪些请求。在这种情况下，您可以创建一个自定义代理函数，根据请求属性有条件地设置代理。

func CustomProxyFunc(req *http.Request) (*url.URL, error) {
    if req.URL.Host == "example.com" {
        return url.Parse("http://your-proxy-server.com:8080")
    }
    return nil, nil
}

以下是如何使用此自定义代理功能：

package main

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

func CustomProxyFunc(req *http.Request) (*url.URL, error) {
    if req.URL.Host == "example.com" {
        return url.Parse("http://your-proxy-server.com:8080")
    }
    return nil, nil
}

func main() {
    transport := &http.Transport{
        Proxy: CustomProxyFunc,
    }

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

    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

此自定义代理函数检查请求是否应通过基于主机的代理。如果是，则返回代理 URL；否则，它返回 nil 以指示直接连接。

设置 HTTPS 连接代理

HTTPS 代理也称为隧道代理，处理加密数据并确保连接的安全性和完整性。您可以使用 Go 的 net/http 包实现 HTTPS 代理。

注意：隧道是 HTTPS 代理用于在客户端和目标服务器之间建立安全连接的一种技术。HTTPS 代理使用CONNECT 方法建立隧道，允许加密数据通过而不会被代理解密。

第1步：导入必要的包

import (
    "context"
    "crypto/tls"
    "fmt"
    "io"
    "net"
    "net/http"
    "net/url"
    "time"
)
  • context：管理 DialContext 函数，该函数使用超时和取消的上下文。
  • crypto/tls：配置安全连接的 TLS 设置。
  • fmt：字符串格式化和打印（例如，创建 CONNECT 请求字符串）。
  • io：从 HTTP 请求中读取响应正文。
  • net：提供网络连接的功能，例如拨号到代理服务器。
  • net/http：创建 HTTP 客户端并发出请求。
  • net/url：用于解析和管理URL。
  • time：设置网络操作超时。

步骤2：解析代理URL

proxyURL, err := url.Parse("http://your-proxy-url:port")
if err != nil {
    // handle error
}

第 3 步：定义DialContext函数

配置传输层以使用自定义 DialContext 函数。此函数处理安全连接隧道的创建。

transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            // Connect to the proxy server
            conn, err := (&net.Dialer{
                Timeout:   30 time.Second,
                KeepAlive: 30  time.Second,
            }).DialContext(ctx, network, proxyURL.Host)
            if err != nil {
                return nil, err
            }

            // Send CONNECT request to the proxy
            connectReq := fmt.Sprintf("CONNECT %s HTTP/1.1\r\nHost: %s\r\n\r\n", addr, addr)
            _, err = conn.Write([]byte(connectReq))
            if err != nil {
                conn.Close()
                return nil, err
            }

            // Read the proxy's response (usually a 200 OK)
            buf := make([]byte, 4096)
            n, err := conn.Read(buf)
            if err != nil {
                conn.Close()
                return nil, err
            }
            if n == 0 || !httpReadOK(buf[:n]) {
                conn.Close()
                return nil, fmt.Errorf("failed to CONNECT to proxy, response: %s", buf[:n])
            }

            return conn, nil
        },
        TLSHandshakeTimeout: 10 * time.Second,
    }

第 4 步：创建 HTTP 客户端

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

步骤 5：发出 HTTPS 请求

使用配置的客户端发出 HTTPS 请求并处理响应：

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(body))
}

这是包含所有步骤的完整代码：

package main

import (
    "context"
    "crypto/tls"
    "fmt"
    "io"
    "net"
    "net/http"
    "net/url"
    "time"
)

func main() {
    proxyURL, _ := url.Parse("http://your-https-proxy.com:8080")
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            // Connect to the proxy server
            conn, err := (&net.Dialer{
                Timeout:   30 * time.Second,
                KeepAlive: 30 * time.Second,
            }).DialContext(ctx, network, proxyURL.Host)
            if err != nil {
                return nil, err
            }

            // Send CONNECT request to the proxy
            connectReq := fmt.Sprintf("CONNECT %s HTTP/1.1\r\nHost: %s\r\n\r\n", addr, addr)
            _, err = conn.Write([]byte(connectReq))
            if err != nil {
                conn.Close()
                return nil, err
            }

            // Read the proxy's response (usually a 200 OK)
            buf := make([]byte, 4096)
            n, err := conn.Read(buf)
            if err != nil {
                conn.Close()
                return nil, err
            }
            if n == 0 || !httpReadOK(buf[:n]) {
                conn.Close()
                return nil, fmt.Errorf("failed to CONNECT to proxy, response: %s", buf[:n])
            }

            return conn, nil
        },
        TLSHandshakeTimeout: 10 * time.Second,
        TLSClientConfig:     &tls.Config{InsecureSkipVerify: true}, // For testing purposes only; do not use in production
    }

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

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(body))
}

// Helper Function to Check Proxy Response

func httpReadOK(data []byte) bool {
    return len(data) >= 12 && string(data[:12]) == "HTTP/1.1 200"
}

您可以通过使用代理设置的环境变量来进一步改进此代码。例如，环境HTTP_PROXY变量HTTPS_PROXY可用于指定 HTTP 和 HTTPS 连接的代理 URL。

export HTTP_PROXY=http://your-http-proxy-url.com:8080
export HTTPS_PROXY=http://your-https-proxy-url.com:8080

设置 SOCKS 代理

SOCKS 代理在比 HTTP 代理更低的级别（网络层）运行。因此它们可以处理任何网络流量，而不仅限于 HTTP。这种灵活性使得 SOCKS 代理对于需要多协议支持的应用程序非常有用。SOCKS 代理通常用于绕过防火墙或访问受限内容，并通过屏蔽用户的 IP 地址来提供匿名性。

要在 Go 中设置 SOCKS 代理，您可以使用该golang.org/x/net/proxy包，它提供了创建和配置各种代理的便捷方法。

第1步：导入必要的包

package main

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

步骤 2：创建 SOCKS5 代理拨号器

使用该proxy.SOCKS5函数创建 SOCKS5 代理拨号器。该函数采用网络类型、SOCKS 代理服务器地址、身份验证和转发代理。

func main() {
    dialer, err := proxy.SOCKS5("tcp", "your-socks-proxy.com:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

步骤 3：配置 HTTP 传输：

设置结构体的 Dial 字段http.Transport以使用SOCKS5 dialer. 这可确保 建立的所有连接都http.Client将通过指定的 SOCKS 代理服务器。

transport := &http.Transport{
        Dial: dialer.Dial,
    }

步骤 4：使用配置的传输创建 HTTP 客户端

初始化http.Client以使用通过 SOCKS 代理路由的自定义传输配置。

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

第 5 步：使用 HTTP 客户端发出请求

使用配置的客户端发出请求。这可确保请求通过 SOCKS 代理。

resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

这是包含所有步骤的完整代码：

package main

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

func main() {
    dialer, err := proxy.SOCKS5("tcp", "your-socks-proxy.com:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    transport := &http.Transport{
        Dial: dialer.Dial,
    }

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

    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

处理认证

某些代理需要身份验证以确保只有授权用户才能访问网络资源。正确的身份验证处理对于网络安全也至关重要。

基本认证

处理基本身份验证的一种方法是将凭据直接包含在代理 URL 中。此方法很简单，但存在安全隐患，因为凭据以明文形式存储在代码中。

package main

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

func ProxyFunc(req *http.Request) (*url.URL, error) {
    return url.Parse("http://username:[email protected]:8080")
}

func main() {
    transport := &http.Transport{
        Proxy: ProxyFunc,
    }

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

    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

高级认证方法

某些代理服务器需要更复杂的身份验证机制，例如NTLM (NT LAN Manager)或Kerberos。这些方法通常涉及额外的库或包来正确处理身份验证过程。

要处理代理服务器的 NTLM 身份验证，您可以使用该github.com/Azure/go-ntlmssp包。

package main

import (
    "github.com/Azure/go-ntlmssp"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, _ := url.Parse("http://your-proxy-server.com:8080")
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        DialContext: (&net.Dialer{
            Timeout:   30 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        TLSHandshakeTimeout: 10 * time.Second,
    }

    client := &http.Client{
        Transport: ntlmssp.Negotiator{
            RoundTripper: transport,
        },
    }

    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}

结论

本文是在 Go 中配置和使用代理的完整指南。它解释了如何使用 Go 配置 HTTP、HTTPS 和 SOCKS 代理，包括使用环境变量和身份验证等最佳实践。在 Go 中设置代理可以显着增强应用程序的网络功能，提供访问受限内容、提高隐私性和促进网络流量调试等好处。Go 的库和包使该过程简单有效，使您能够构建强大且安全的网络应用程序。

发表回复

Your email address will not be published. Required fields are marked *

*

Registration complete !

Show

Already have an account ?

Reset your password

Please enter your email address. You will receive a link to create a new password.

Check your e-mail for the confirmation link.

Remember your password ?

Close