i/o 超时问题和 https 内存泄漏在 SQS 中的表现

有志者，事竟成！如果你在学习Golang，那么本文《i/o 超时问题和 https 内存泄漏在 SQS 中的表现》，就很适合你！文章讲解的知识点主要包括，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

aws 开发工具包版本：v1.38.19

go版本：go1.15.7

阿尔卑斯3.7

我正在使用标准队列 我正在我的应用程序中立即初始化 sqs 连接，如下所示；

// connection connection to the sqs
var connection *sqs.sqs

// initsqs initialize the aws sqs connection
func initsqs() {
    sess := session.must(session.newsessionwithoptions(session.options{
        sharedconfigstate: session.sharedconfigenable,
    }))

    connection = sqs.new(sess, &aws.config{
        region:     aws.string("eu-west-1"),
        disablessl: aws.bool(true),
    })
}

我禁用 ssl 因为；当我在应用程序中使用 ssl 时，我遇到内存和 cpu 泄漏（我的应用程序不对世界其他地方开放，顺便说一句，它是我其他应用程序的内部服务）。

这是我用来从 sqs 读取消息的配置：

func consumeupdatemessage(db *database.mysqlwrap, sqsapi queue.sqsapi) error {
    result, err := sqsapi.receivemessage(&sqs.receivemessageinput{
        attributenames: []*string{
            aws.string(sqs.messagesystemattributenamesenttimestamp),
        },
        messageattributenames: []*string{
            aws.string(sqs.queueattributenameall),
        },
        queueurl:            &qurl,
        maxnumberofmessages: aws.int64(10),
        waittimeseconds:     aws.int64(20),
    })

    if err != nil {
        return fmt.errorf("error on receiving the message from queue: %s", err.error())
    }

    for _, msg := range result.messages {
            // business logic
        }

    return err
}

这就是我调用 consumeupdatemessage 方法的方式；

// initializeupdatemessage ..
func initializeupdatemessage(db *database.mysqlwrap, sqsapi queue.sqsapi) {
    go func() {
        for {
            time.sleep(500 * time.millisecond)

            err := consumeupdatemessage(db, sqsapi)

            if err != nil {
                log.error(err)

                continue
            }
        }
    }()
}

但有时我的订阅者会返回这样的错误；

*awserr.baseError: RequestError: send request failed
caused by: Post "http://sqs.eu-west-1.amazonaws.com/": dial tcp xx.x.xx.xxx:80: i/o timeout

（注意：我输入了 xx 而不是共享 ip 地址）

我在论坛和其他地方进行了搜索，但找不到这两个问题的解决方案，

1. 当我使用 ssl 连接时出现内存泄漏（想法：但由于我的应用程序是内部服务，我认为我不必使用 ssl）
2. 输入/输出超时

正确答案

这是一个很晚的答案，但我遇到了类似的问题，我想我发现了问题所在：您为长轮询设置了 20 秒的 waittimeseconds （这是一个好主意），但是 http 客户端时间比那更早。

waittimeseconds 的文档说：

// to avoid http errors, ensure that the http response timeout for receivemessage
// requests is longer than the waittimeseconds parameter. for example, with
// the java sdk, you can set http transport settings using the nettynioasynchttpclient
// (https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/nettynioasynchttpclient.html)
// for asynchronous clients, or the apachehttpclient (https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/apachehttpclient.html)
// for synchronous clients.

至少，从 aws-sdk-go 的 v1.44.39 开始。

以下页面介绍了如何配置自定义 http 客户端：https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/custom-http.html

为了后代，我将该页面的所有代码复制到此处：

type HTTPClientSettings struct {
    Connect          time.Duration
    ConnKeepAlive    time.Duration
    ExpectContinue   time.Duration
    IdleConn         time.Duration
    MaxAllIdleConns  int
    MaxHostIdleConns int
    ResponseHeader   time.Duration
    TLSHandshake     time.Duration
}

func NewHTTPClientWithSettings(httpSettings HTTPClientSettings) (*http.Client, error) {
    var client http.Client
    tr := &http.Transport{
        ResponseHeaderTimeout: httpSettings.ResponseHeader,
        Proxy:                 http.ProxyFromEnvironment,
        DialContext: (&net.Dialer{
            KeepAlive: httpSettings.ConnKeepAlive,
            DualStack: true,
            Timeout:   httpSettings.Connect,
        }).DialContext,
        MaxIdleConns:          httpSettings.MaxAllIdleConns,
        IdleConnTimeout:       httpSettings.IdleConn,
        TLSHandshakeTimeout:   httpSettings.TLSHandshake,
        MaxIdleConnsPerHost:   httpSettings.MaxHostIdleConns,
        ExpectContinueTimeout: httpSettings.ExpectContinue,
    }

    // So client makes HTTP/2 requests
    err := http2.ConfigureTransport(tr)
    if err != nil {
        return &client, err
    }

    return &http.Client{
        Transport: tr,
    }, nil
}

httpClient, err := NewHTTPClientWithSettings(HTTPClientSettings{
    Connect:          5 * time.Second,
    ExpectContinue:   1 * time.Second,
    IdleConn:         90 * time.Second,
    ConnKeepAlive:    30 * time.Second,
    MaxAllIdleConns:  100,
    MaxHostIdleConns: 10,
    ResponseHeader:   5 * time.Second,
    TLSHandshake:     5 * time.Second,
})
if err != nil {
    fmt.Println("Got an error creating custom HTTP client:")
    fmt.Println(err)
    return
}

sess := session.Must(session.NewSession(&aws.Config{
    HTTPClient: httpClient,
}))

sqsClient := sqs.New(sess)

您将需要配置超时设置。特别是，我将 connect、tlshandshake 和 responseheader 设置为 25 秒，并且不再出现任何错误。

理论要掌握，实操不能落！以上关于《i/o 超时问题和 https 内存泄漏在 SQS 中的表现》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！