Go Transport连接保活场景下DNS变更响应方案咨询

Great question—this is a common gotcha with Go's http.Transport and connection pooling, especially when dealing with upstream services that might rotate their IPs via DNS. Let's break down the problem first, then walk through three practical solutions that fit different use cases:

The Core Issue #

Go's http.Transport caches connections by hostname, but those connections are tied to the specific IP resolved at the time the connection was first established. Even if the DNS record changes, existing open connections (whether idle or active) will keep using the old IP until they're closed. Since your setup reuses connections well within the IdleConnTimeout, those old IP connections stick around indefinitely.

Solution 1: Periodically Close Idle Connections (Simplest Approach) #

If you can tolerate a small delay (e.g., 30-60 seconds) between DNS changes and proxy switching to the new IP, this is the easiest fix. The http.Transport has a CloseIdleConnections() method that only closes connections that are not currently handling requests—so active requests won't be interrupted.

You can set up a background ticker to call this method on a regular interval:

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "time"
)

func main() {
    // Configure your transport as before
    transport := &http.Transport{
        DisableKeepAlives: false,
        IdleConnTimeout:   60 * time.Second,
        // Add any other transport configs here
    }

    // Start a background goroutine to close idle connections every 30 seconds
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()
        for range ticker.C {
            transport.CloseIdleConnections()
            log.Println("Closed idle connections to refresh DNS")
        }
    }()

    // Set up your reverse proxy
    proxy := &httputil.ReverseProxy{
        Transport: transport,
        Director: func(req *http.Request) {
            req.URL.Scheme = "http"
            req.URL.Host = "your-upstream-host.com"
            // Adjust other request attributes as needed
        },
    }

    // Start your proxy server
    log.Fatal(http.ListenAndServe(":8080", proxy))
}

Pros: Minimal code changes, no impact on active requests, works with existing transport config.
Cons: Switch to new IP is delayed by your ticker interval; doesn't handle cases where you need immediate DNS refresh.

Solution 2: Custom DialContext with DNS Caching (More Control) #

If you want to control exactly when DNS is re-resolved (instead of relying on idle connection timeouts), you can override the DialContext function in your transport. This lets you implement a DNS cache with a fixed TTL, so every time the cache expires, new connections will use the latest IP.

Here's an example using a simple in-memory cache for DNS records:

package main

import (
    "context"
    "fmt"
    "net"
    "net/http"
    "net/http/httputil"
    "time"

    "github.com/patrickmn/go-cache"
)

func main() {
    // Create a DNS cache with 30-second TTL and 1-minute cleanup interval
    dnsCache := cache.New(30*time.Second, 60*time.Second)

    transport := &http.Transport{
        DisableKeepAlives: false,
        IdleConnTimeout:   60 * time.Second,
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            // Split the address into host and port
            host, port, err := net.SplitHostPort(addr)
            if err != nil {
                return nil, err
            }

            // Check if we have a cached IP for the host
            if cachedIP, found := dnsCache.Get(host); found {
                addr = net.JoinHostPort(cachedIP.(string), port)
            } else {
                // Resolve the host's IPs
                ips, err := net.LookupIP(host)
                if err != nil {
                    return nil, fmt.Errorf("failed to resolve %s: %w", host, err)
                }
                if len(ips) == 0 {
                    return nil, fmt.Errorf("no IPs found for %s", host)
                }

                // Use the first IP (you could implement round-robin here for multiple IPs)
                ipStr := ips[0].String()
                dnsCache.Set(host, ipStr, cache.DefaultExpiration)
                addr = net.JoinHostPort(ipStr, port)
            }

            // Use the default dialer to create the connection
            defaultDialer := &net.Dialer{}
            return defaultDialer.DialContext(ctx, network, addr)
        },
    }

    proxy := &httputil.ReverseProxy{
        Transport: transport,
        Director: func(req *http.Request) {
            req.URL.Scheme = "http"
            req.URL.Host = "your-upstream-host.com"
        },
    }

    log.Fatal(http.ListenAndServe(":8080", proxy))
}

Pros: Precise control over DNS refresh timing; works with connection pooling; can add logic like round-robin for multiple upstream IPs.
Cons: Requires adding a caching library (or implementing your own); slightly more complex setup.

Solution 3: Rotating Transport Pool (Strict Connection Lifecycle) #

If you need to guarantee that no connections to the old IP exist after a certain time (e.g., for compliance or strict failover), you can implement a rotating pool of http.Transport instances. Every N seconds, you create a new transport (which will resolve the latest DNS), and retire the old one after its idle connections have timed out.

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "sync"
    "time"
)

type RotatingTransport struct {
    mu         sync.RWMutex
    current    *http.Transport
    updateFreq time.Duration
}

func NewRotatingTransport(updateFreq time.Duration) *RotatingTransport {
    rt := &RotatingTransport{
        updateFreq: updateFreq,
    }
    rt.current = rt.newTransport()
    go rt.startRotation()
    return rt
}

func (rt *RotatingTransport) newTransport() *http.Transport {
    return &http.Transport{
        DisableKeepAlives: false,
        IdleConnTimeout:   60 * time.Second,
        // Add your transport configs here
    }
}

func (rt *RotatingTransport) startRotation() {
    ticker := time.NewTicker(rt.updateFreq)
    defer ticker.Stop()
    for range ticker.C {
        rt.mu.Lock()
        oldTransport := rt.current
        rt.current = rt.newTransport()
        rt.mu.Unlock()

        // Wait for old transport's idle connections to expire, then clean it up
        go func() {
            time.Sleep(oldTransport.IdleConnTimeout + time.Second)
            oldTransport.CloseIdleConnections()
            oldTransport.Close()
            log.Println("Retired old transport and cleaned up connections")
        }()
    }
}

func (rt *RotatingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    rt.mu.RLock()
    transport := rt.current
    rt.mu.RUnlock()
    return transport.RoundTrip(req)
}

func main() {
    // Rotate transports every 30 seconds
    rotatingTransport := NewRotatingTransport(30 * time.Second)

    proxy := &httputil.ReverseProxy{
        Transport: rotatingTransport,
        Director: func(req *http.Request) {
            req.URL.Scheme = "http"
            req.URL.Host = "your-upstream-host.com"
        },
    }

    log.Fatal(http.ListenAndServe(":8080", proxy))
}

Pros: Ensures no lingering connections to old IPs after the rotation interval; active requests on old transports are allowed to complete.
Cons: Most complex implementation; requires managing transport lifecycle to avoid resource leaks.

Which Solution Should You Choose? #

• Use Solution 1 if you want minimal work and can tolerate small DNS switch delays.
• Use Solution 2 if you need granular control over DNS refresh or want to add load balancing across upstream IPs.
• Use Solution 3 if you have strict requirements to eliminate old IP connections after a fixed time.

All these solutions avoid interrupting active requests, which addresses your concern about high-traffic scenarios.

内容的提问来源于stack exchange，提问作者Austin Platt