Question

我正在研究一个示例项目，该项目从bigquery获取输出并将其发布到pubsub。 bigquery的行输出可能大于100,000。我看到有批量发布的选项，并且我在多个地方都读到，每批1k消息是理想的选择。我遇到的问题是我一生都无法批量处理多封邮件，我认为解决方案很简单，但是我却错过了这样做的方法。

这是我现在拥有的，它所做的只是一次发布一封邮件。

func publish(client pubsub.Client, data []byte) (string, error) {
    ctx := context.Background()

    topic := client.Topic("topic-name")
    topic.PublishSettings = pubsub.PublishSettings{
        // ByteThreshold:  5000,
        CountThreshold: 1000, // no matter what I put here it still sends one per publish
        // DelayThreshold: 1000 * time.Millisecond,
    }

    result := topic.Publish(ctx, &pubsub.Message{
        Data: data,
    })

    id, err := result.Get(ctx)
    if err != nil {
        return "", err
    }

    return id, nil
}

此函数的调用者：

for _, v := range qr {
        data, err := json.Marshal(v)
        if err != nil {
            log.Printf("Unable to marshal %s", data)
            continue
        }
        id, err := publish(*pubsubClient, data)
        if err != nil {
            log.Printf("Unable to publish message: %s", data)
        }
        log.Printf("Published message with id: %s", id)
    }

其中qr是包含从bigquery查询返回的数据的结构片段。

现在，是否由于我如何调用函数publish而使每个消息都被发布，而topic.PublishSettings被每个方法调用覆盖了，所以它忘记了之前的消息？我在这里茫然。

我在这里看到了一些批处理发布代码：https://github.com/GoogleCloudPlatform/golang-samples/blob/master/pubsub/topics/main.go#L217

但是他们实际上并没有在示例中调用它，所以我不知道应该怎么做。

请注意并进一步证明我的观点它不起作用，如果我将DelayThreshold变量中的topic.PublishSettings设置为1秒，那么它只是每秒发布一条消息，而不是所有应该在内存中的消息。

感谢帮助。

编辑＃1：

因此，使用kingkupps注释，出于测试目的，我将代码切换为以下代码：（项目名称和主题名称从真实名称转换为）

func QueryAndPublish(w http.ResponseWriter, r *http.Request) {
    ctx := context.Background()
    // setting up the pubsub client
    pubsubClient, err := pubsub.NewClient(ctx, "fake-project-id")
    if err != nil {
        log.Fatalf("Unable to get pubsub client: %v", err)
    }

    // init topic and settings for publishing 1000 messages in batch
    topic := pubsubClient.Topic("fake-topic")
    topic.PublishSettings = pubsub.PublishSettings{
        // ByteThreshold:  5000,
        CountThreshold: 1000,
        // DelayThreshold: 1000 * time.Millisecond,
    }

    // bq set up
    bqClient, err := bigquery.NewClient(ctx, "fake-project-id")
    if err != nil {
        log.Fatalf("Unable to get bq client: %v", err)
    }
    // bq query function call
    qr, err := query(*bqClient)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Got query results, publishing now")

    // marshalling messages to json format
    messages := make([][]byte, len(qr))
    timeToMarshal := time.Now()
    for i, v := range qr {
        data, err := json.Marshal(v)
        if err != nil {
            log.Printf("Unable to marshal %s", data)
            continue
        }
        messages[i] = data
    }
    elapsedMarshal := time.Since(timeToMarshal).Nanoseconds() / 1000000
    log.Printf("Took %v ms to marshal %v messages", elapsedMarshal, len(messages))

    // publishing messages
    timeToPublish := time.Now()
    publishCount := 0
    for _, v := range messages {
        // ignore result, err from topic.Publish return, just publish
        topic.Publish(ctx, &pubsub.Message{
            Data: v,
        })
        publishCount++
    }
    elapsedPublish := time.Since(timeToPublish).Nanoseconds() / 1000000
    log.Printf("Took %v ms to publish %v messages", elapsedPublish, publishCount)

    fmt.Fprint(w, "Job completed")
}

现在的操作是，当我的消息计数为100,000时，它将在大约600毫秒内完成发布调用，但是在后台，它将仍然一一发布到pubsub端点。

我可以在StackDriver和Wireshark中看到这一点，其中我在stackdriver中的消息/秒大约为10-16 /秒，而Wireshark在发送的每条消息中显示新连接。

Answer 1

这可能是因为您打电话时

topic.PublishSettings = pubsub.PublishSettings{ // ByteThreshold: 5000, CountThreshold: 1000, // DelayThreshold: 1000 * time.Millisecond, }

您正在将发布设置重置为零初始化的结构。这会将topic.PublishSettings.ByteThreshold设置为0，这意味着所有消息都将立即发布。您告诉它等待直到它有0个字节，并且它始终有0个字节。

相反，您应该执行以下操作来设置CountThreshold：

topic.PublishSettings.CountThreshold = 1000

其他字段也是如此。它们已经按照here的描述初始化为默认值，如果要更改它们，请直接修改它们，而不是重新分配整个PublishSetttings对象。

转到GCP Cloud PubSub，而不是批量发布消息

1 个答案: