消息发布与订阅 on Dapr 文档库

发布-订阅模式概述

Mon, 01 Jan 0001 00:00:00 +0000

发布-订阅模式（pubsub）使微服务能够通过消息进行事件驱动的架构通信。

生产者或发布者将消息写入输入通道并发送到主题，而不关心哪个应用程序会接收它们。
消费者或订阅者订阅主题并从输出通道接收消息，而不关心哪个服务生成了这些消息。

消息代理会将每条消息从发布者的输入通道复制到所有对该消息感兴趣的订阅者的输出通道。这种模式在需要将微服务解耦时特别有用。

pubsub API

在 Dapr 中，pubsub API：

提供一个平台无关的 API 来发送和接收消息。
确保消息至少被传递一次。
与多种消息代理和队列系统集成。

您可以在运行时配置 Dapr pubsub 组件来使用特定的消息代理，这种可插拔性使您的服务更具可移植性和灵活性。

在 Dapr 中使用 pubsub 时：

您的服务通过网络调用 Dapr pubsub 构建块 API。
pubsub 构建块调用封装特定消息代理的 Dapr pubsub 组件。
为了接收主题上的消息，Dapr 代表您的服务订阅 pubsub 组件，并在消息到达时将其传递到您的服务的端点。

以下概述视频和演示展示了 Dapr pubsub 的工作原理。

在下图中，“shipping”服务和“email”服务都已订阅由“cart”服务发布的主题。每个服务加载指向相同 pubsub 消息代理组件的 pubsub 组件配置文件；例如：Redis Streams、NATS Streaming、Azure Service Bus 或 GCP pubsub。

在下图中，Dapr API 将“cart”服务的“order”主题发布到“shipping”和“email”订阅服务的“order”端点。

查看 Dapr 支持的 pubsub 组件的完整列表。

如何：发布消息并订阅主题

Mon, 01 Jan 0001 00:00:00 +0000

既然您已经了解了Dapr pubsub构建块的功能，接下来我们来看看如何在您的服务中应用它。下面的代码示例描述了一个使用两个服务处理订单的应用程序，每个服务都有Dapr sidecar：

一个结账服务，使用Dapr订阅消息队列中的主题。
一个订单处理服务，使用Dapr向RabbitMQ发布消息。

Dapr会自动将用户的负载封装在符合CloudEvents v1.0的格式中，并使用Content-Type头的值作为datacontenttype属性。了解更多关于CloudEvents的消息。

以下示例展示了如何在您的应用程序中发布和订阅名为orders的主题。

注意

如果您还没有，请尝试pubsub快速入门，快速了解如何使用pubsub。

设置Pub/Sub组件

第一步是设置pubsub组件：

当您运行dapr init时，Dapr会创建一个默认的Redis pubsub.yaml并在您的本地机器上运行一个Redis容器，位置如下：

在Windows上，位于%UserProfile%\.dapr\components\pubsub.yaml
在Linux/MacOS上，位于~/.dapr/components/pubsub.yaml

使用pubsub.yaml组件，您可以轻松地更换底层组件而无需更改应用程序代码。在此示例中，使用RabbitMQ。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
 name: order-pub-sub
spec:
 type: pubsub.rabbitmq
 version: v1
 metadata:
 - name: host
 value: "amqp://localhost:5672"
 - name: durable
 value: "false"
 - name: deletedWhenUnused
 value: "false"
 - name: autoAck
 value: "false"
 - name: reconnectWait
 value: "0"
 - name: concurrency
 value: parallel
scopes:
 - orderprocessing
 - checkout

您可以通过创建一个包含该文件的组件目录（在此示例中为myComponents）并使用dapr run CLI命令的--resources-path标志来覆盖此文件。

使用 CloudEvents 进行消息传递

Mon, 01 Jan 0001 00:00:00 +0000

为了实现消息路由并为每条消息提供额外的上下文，Dapr 采用 CloudEvents 1.0 规范作为其消息格式。通过 Dapr 发送到主题的任何消息都会自动被包装在 CloudEvents 信封中，使用 Content-Type 头部值作为 datacontenttype 属性。

Dapr 使用 CloudEvents 为事件负载提供额外的上下文，从而实现以下功能：

跟踪
事件数据的正确反序列化的内容类型
发送应用程序的验证

您可以选择以下三种方法之一通过发布订阅发布 CloudEvent：

发送一个发布订阅事件，然后由 Dapr 包装在 CloudEvent 信封中。
通过覆盖标准 CloudEvent 属性来替换 Dapr 提供的特定 CloudEvents 属性。
将您自己的 CloudEvent 信封作为发布订阅事件的一部分编写。

Dapr 生成的 CloudEvents 示例

向 Dapr 发送发布操作会自动将其包装在一个包含以下字段的 CloudEvent 信封中：

id
source
specversion
type
traceparent
traceid
tracestate
topic
pubsubname
time
datacontenttype (可选)

以下示例演示了 Dapr 为发布到 orders 主题的操作生成的 CloudEvent，其中包括：

一个 W3C traceid，唯一标识消息
data 和 CloudEvent 的字段，其中数据内容被序列化为 JSON

{
 "topic": "orders",
 "pubsubname": "order_pub_sub",
 "traceid": "00-113ad9c4e42b27583ae98ba698d54255-e3743e35ff56f219-01",
 "tracestate": "",
 "data": {
 "orderId": 1
 },
 "id": "5929aaac-a5e2-4ca1-859c-edfe73f11565",
 "specversion": "1.0",
 "datacontenttype": "application/json; charset=utf-8",
 "source": "checkout",
 "type": "com.dapr.event.sent",
 "time": "2020-09-23T06:23:21Z",
 "traceparent": "00-113ad9c4e42b27583ae98ba698d54255-e3743e35ff56f219-01"
}

作为另一个 v1.0 CloudEvent 的示例，以下显示了在 CloudEvent 消息中以 JSON 序列化的 XML 内容的数据：

发布和订阅非CloudEvents消息

Mon, 01 Jan 0001 00:00:00 +0000

在将Dapr集成到您的应用程序时，由于兼容性原因或某些应用程序不使用Dapr，某些服务可能仍需要通过不封装在CloudEvents中的pub/sub消息进行通信。这些消息被称为“原始”pub/sub消息。Dapr允许应用程序发布和订阅原始事件，这些事件未封装在CloudEvent中以实现兼容性。

发布原始消息

Dapr应用程序可以将原始事件发布到pub/sub主题中，而不需要CloudEvent封装，以便与非Dapr应用程序兼容。

警告

不使用CloudEvents会禁用对跟踪、每个messageId的事件去重、内容类型元数据以及任何其他基于CloudEvent架构构建的功能的支持。

要禁用CloudEvent封装，请在发布请求中将rawPayload元数据设置为true。这样，订阅者可以接收这些消息而无需解析CloudEvent架构。

curl -X "POST" http://localhost:3500/v1.0/publish/pubsub/TOPIC_A?metadata.rawPayload=true -H "Content-Type: application/json" -d '{"order-number": "345"}'

from dapr.clients import DaprClient

with DaprClient() as d:
 req_data = {
 'order-number': '345'
 }
 # 创建一个带有内容类型和主体的类型化消息
 resp = d.publish_event(
 pubsub_name='pubsub',
 topic_name='TOPIC_A',
 data=json.dumps(req_data),
 publish_metadata={'rawPayload': 'true'}
 )
 # 打印请求
 print(req_data, flush=True)

<?php

require_once __DIR__.'/vendor/autoload.php';

$app = \Dapr\App::create();
$app->run(function(\DI\FactoryInterface $factory) {
 $publisher = $factory->make(\Dapr\PubSub\Publish::class, ['pubsub' => 'pubsub']);
 $publisher->topic('TOPIC_A')->publish('data', ['rawPayload' => 'true']);
});

订阅原始消息

Dapr应用程序还可以订阅来自不使用CloudEvent封装的现有pub/sub主题的原始事件。

操作指南：将消息路由到不同的事件处理程序

Mon, 01 Jan 0001 00:00:00 +0000

pubsub 路由实现了基于内容的路由，这是一种使用 DSL 而不是命令式应用程序代码的消息模式。通过 pubsub 路由，您可以根据 CloudEvents 的内容，将消息路由到应用程序中的不同 URI/路径和事件处理程序。如果没有匹配的路由，则可以使用可选的默认路由。随着您的应用程序扩展以支持多个事件版本或特殊情况，这种方法将非常有用。

虽然可以通过代码实现路由，但将路由规则与应用程序分离可以提高可移植性。

此功能适用于声明式和编程式订阅方法，但不适用于流式订阅。

声明式订阅

对于声明式订阅，使用 dapr.io/v2alpha1 作为 apiVersion。以下是使用路由的 subscriptions.yaml 示例：

apiVersion: dapr.io/v2alpha1
kind: Subscription
metadata:
 name: myevent-subscription
spec:
 pubsubname: pubsub
 topic: inventory
 routes:
 rules:
 - match: event.type == "widget"
 path: /widgets
 - match: event.type == "gadget"
 path: /gadgets
 default: /products
scopes:
 - app1
 - app2

编程式订阅

在编程方法中，返回的是 routes 结构而不是 route。JSON 结构与声明式 YAML 匹配：

import flask
from flask import request, jsonify
from flask_cors import CORS
import json
import sys

app = flask.Flask(__name__)
CORS(app)

@app.route('/dapr/subscribe', methods=['GET'])
def subscribe():
 subscriptions = [
 {
 'pubsubname': 'pubsub',
 'topic': 'inventory',
 'routes': {
 'rules': [
 {
 'match': 'event.type == "widget"',
 'path': '/widgets'
 },
 {
 'match': 'event.type == "gadget"',
 'path': '/gadgets'
 },
 ],
 'default': '/products'
 }
 }]
 return jsonify(subscriptions)

@app.route('/products', methods=['POST'])
def ds_subscriber():
 print(request.json, flush=True)
 return json.dumps({'success':True}), 200, {'ContentType':'application/json'}
app.run()

const express = require('express')
const bodyParser = require('body-parser')
const app = express()
app.use(bodyParser.json({ type: 'application/*+json' }));

const port = 3000

app.get('/dapr/subscribe', (req, res) => {
 res.json([
 {
 pubsubname: "pubsub",
 topic: "inventory",
 routes: {
 rules: [
 {
 match: 'event.type == "widget"',
 path: '/widgets'
 },
 {
 match: 'event.type == "gadget"',
 path: '/gadgets'
 },
 ],
 default: '/products'
 }
 }
 ]);
})

app.post('/products', (req, res) => {
 console.log(req.body);
 res.sendStatus(200);
});

app.listen(port, () => console.log(`consumer app listening on port ${port}!`))

 [Topic("pubsub", "inventory", "event.type ==\"widget\"", 1)]
 [HttpPost("widgets")]
 public async Task<ActionResult<Stock>> HandleWidget(Widget widget, [FromServices] DaprClient daprClient)
 {
 // Logic
 return stock;
 }

 [Topic("pubsub", "inventory", "event.type ==\"gadget\"", 2)]
 [HttpPost("gadgets")]
 public async Task<ActionResult<Stock>> HandleGadget(Gadget gadget, [FromServices] DaprClient daprClient)
 {
 // Logic
 return stock;
 }

 [Topic("pubsub", "inventory")]
 [HttpPost("products")]
 public async Task<ActionResult<Stock>> HandleProduct(Product product, [FromServices] DaprClient daprClient)
 {
 // Logic
 return stock;
 }

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

const appPort = 3000

type subscription struct {
	PubsubName string `json:"pubsubname"`
	Topic string `json:"topic"`
	Metadata map[string]string `json:"metadata,omitempty"`
	Routes routes `json:"routes"`
}

type routes struct {
	Rules []rule `json:"rules,omitempty"`
	Default string `json:"default,omitempty"`
}

type rule struct {
	Match string `json:"match"`
	Path string `json:"path"`
}

// This handles /dapr/subscribe
func configureSubscribeHandler(w http.ResponseWriter, _ *http.Request) {
	t := []subscription{
		{
			PubsubName: "pubsub",
			Topic: "inventory",
			Routes: routes{
				Rules: []rule{
					{
						Match: `event.type == "widget"`,
						Path: "/widgets",
					},
					{
						Match: `event.type == "gadget"`,
						Path: "/gadgets",
					},
				},
				Default: "/products",
			},
		},
	}

	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(t)
}

func main() {
	router := mux.NewRouter().StrictSlash(true)
	router.HandleFunc("/dapr/subscribe", configureSubscribeHandler).Methods("GET")
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", appPort), router))
}

<?php

require_once __DIR__.'/vendor/autoload.php';

$app = \Dapr\App::create(configure: fn(\DI\ContainerBuilder $builder) => $builder->addDefinitions(['dapr.subscriptions' => [
 new \Dapr\PubSub\Subscription(pubsubname: 'pubsub', topic: 'inventory', routes: (
 rules: => [
 ('match': 'event.type == "widget"', path: '/widgets'),
 ('match': 'event.type == "gadget"', path: '/gadgets'),
 ]
 default: '/products')),
]]));
$app->post('/products', function(
 #[\Dapr\Attributes\FromBody]
 \Dapr\PubSub\CloudEvent $cloudEvent,
 \Psr\Log\LoggerInterface $logger
 ) {
 $logger->alert('Received event: {event}', ['event' => $cloudEvent]);
 return ['status' => 'SUCCESS'];
 }
);
$app->start();

通用表达式语言 (CEL)

在这些示例中，根据 event.type，应用程序将被调用于：

声明式、流式和编程式订阅类型

Mon, 01 Jan 0001 00:00:00 +0000

发布/订阅 API 订阅类型

Dapr 应用程序可以通过三种订阅类型来订阅已发布的主题，这三种类型支持相同的功能：声明式、流式和编程式。

订阅类型	描述
声明式	订阅在外部文件中定义。声明式方法将 Dapr 的依赖从代码中移除，允许现有应用程序无需更改代码即可订阅主题。
流式	订阅在应用程序代码中定义。流式订阅是动态的，允许在运行时添加或删除订阅。它们不需要在应用程序中设置订阅端点（这是编程式和声明式订阅所需的），使其在代码中易于配置。流式订阅也不需要应用程序配置 sidecar 来接收消息。
编程式	订阅在应用程序代码中定义。编程式方法实现了静态订阅，并需要在代码中设置一个端点。

下面的示例演示了通过 orders 主题在 checkout 应用程序和 orderprocessing 应用程序之间的发布/订阅消息。示例首先以声明式，然后以编程式演示了相同的 Dapr 发布/订阅组件。

声明式订阅

注意

此功能目前处于预览状态。 Dapr 可以实现“热重载”声明式订阅，从而在不需要重启的情况下自动获取更新。这通过 HotReload 功能门控启用。为了防止重新处理或丢失未处理的消息，在 Dapr 和您的应用程序之间的飞行消息在热重载事件期间不受影响。

您可以使用外部组件文件声明性地订阅一个主题。此示例使用名为 subscription.yaml 的 YAML 组件文件：

apiVersion: dapr.io/v2alpha1
kind: Subscription
metadata:
 name: order
spec:
 topic: orders
 routes:
 default: /orders
 pubsubname: pubsub
scopes:
- orderprocessing

这里的订阅名为 order：

使用名为 pubsub 的发布/订阅组件订阅名为 orders 的主题。
设置 route 字段以将所有主题消息发送到应用程序中的 /orders 端点。
设置 scopes 字段以将此订阅的访问范围仅限于 ID 为 orderprocessing 的应用程序。

运行 Dapr 时，设置 YAML 组件文件路径以指向 Dapr 的组件。

死信主题

Mon, 01 Jan 0001 00:00:00 +0000

介绍

在某些情况下，应用程序可能由于各种原因无法处理消息。例如，可能会出现获取处理消息所需数据的临时问题，或者应用程序的业务逻辑失败并返回错误。死信主题用于处理这些无法投递的消息，并将其转发到订阅应用程序。这可以减轻应用程序处理失败消息的负担，使开发人员可以编写代码从死信主题中读取消息，修复后重新发送，或者选择放弃这些消息。

死信主题通常与重试策略和处理死信主题消息的订阅一起使用。

当配置了死信主题时，任何无法投递到应用程序的消息都会被放置在死信主题中，以便转发到处理这些消息的订阅。这可以是同一个应用程序或完全不同的应用程序。

即使底层系统不支持，Dapr 也为其所有的 pubsub 组件启用了死信主题。例如，AWS SNS 组件有一个死信队列，RabbitMQ有死信主题。您需要确保正确配置这些组件。

下图展示了死信主题的工作原理。首先，消息从 orders 主题的发布者发送。Dapr 代表订阅者应用程序接收消息，但 orders 主题的消息未能投递到应用程序的 /checkout 端点，即使经过重试也是如此。由于投递失败，消息被转发到 poisonMessages 主题，该主题将其投递到 /failedMessages 端点进行处理，在这种情况下是在同一个应用程序上。failedMessages 处理代码可以选择丢弃消息或重新发送新消息。

使用声明式订阅配置死信主题

以下 YAML 显示了如何为从 orders 主题消费的消息配置名为 poisonMessages 的死信主题。此订阅的范围限定为具有 checkout ID 的应用程序。

apiVersion: dapr.io/v2alpha1
kind: Subscription
metadata:
 name: order
spec:
 topic: orders
 routes: 
 default: /checkout
 pubsubname: pubsub
 deadLetterTopic: poisonMessages
scopes:
- checkout

使用流式订阅配置死信主题

	var deadLetterTopic = "poisonMessages"
	sub, err := cl.Subscribe(context.Background(), client.SubscriptionOptions{
		PubsubName: "pubsub",
		Topic: "orders",
		DeadLetterTopic: &deadLetterTopic,
	})

使用编程订阅配置死信主题

从 /subscribe 端点返回的 JSON 显示了如何为从 orders 主题消费的消息配置名为 poisonMessages 的死信主题。

如何：设置 pub/sub 命名空间消费者组

Mon, 01 Jan 0001 00:00:00 +0000

您已经配置了 Dapr 的 pub/sub API 构建块，并且您的应用程序正在使用集中式消息代理顺利地发布和订阅主题。如果您想为应用程序执行简单的 A/B 测试、蓝/绿部署，甚至金丝雀部署，该怎么办？即使使用 Dapr，这也可能很困难。

Dapr 通过其 pub/sub 命名空间消费者组机制解决了大规模的多租户问题。

没有命名空间消费者组

假设您有一个 Kubernetes 集群，其中两个应用程序（App1 和 App2）部署在同一个命名空间（namespace-a）中。App2 发布到一个名为 order 的主题，而 App1 订阅名为 order 的主题。这将创建两个以您的应用程序命名的消费者组（App1 和 App2）。

为了在使用集中式消息代理时进行简单的测试和部署，您创建了另一个命名空间，其中包含两个具有相同 app-id 的应用程序，App1 和 App2。

Dapr 使用单个应用程序的 app-id 创建消费者组，因此消费者组名称将保持为 App1 和 App2。

为了避免这种情况，您需要在代码中“潜入”一些东西来更改 app-id，具体取决于您运行的命名空间。这种方法既麻烦又容易出错。

使用命名空间消费者组

Dapr 不仅允许您使用 UUID 和 pod 名称的 consumerID 更改消费者组的行为，还提供了一个存在于 pub/sub 组件元数据中的 命名空间机制。例如，使用 Redis 作为您的消息代理：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
 name: pubsub
spec:
 type: pubsub.redis
 version: v1
 metadata:
 - name: redisHost
 value: localhost:6379
 - name: redisPassword
 value: ""
 - name: consumerID
 value: "{namespace}"

通过将 consumerID 配置为 {namespace} 值，您可以在不同的命名空间中使用相同的 app-id 和相同的主题。

如何：使用StatefulSets水平扩展订阅者

Mon, 01 Jan 0001 00:00:00 +0000

与在Deployments中Pod是临时的不同，StatefulSets通过为每个Pod保持固定的身份，使得在Kubernetes上可以部署有状态应用程序。

以下是一个使用Dapr的StatefulSet示例：

apiVersion: apps/v1
kind: StatefulSet
metadata:
 name: python-subscriber
spec:
 selector:
 matchLabels:
 app: python-subscriber  # 必须匹配.spec.template.metadata.labels
 serviceName: "python-subscriber"
 replicas: 3
 template:
 metadata:
 labels:
 app: python-subscriber # 必须匹配.spec.selector.matchLabels
 annotations:
 dapr.io/enabled: "true"
 dapr.io/app-id: "python-subscriber"
 dapr.io/app-port: "5001"
 spec:
 containers:
 - name: python-subscriber
 image: ghcr.io/dapr/samples/pubsub-python-subscriber:latest
 ports:
 - containerPort: 5001
 imagePullPolicy: Always

在通过Dapr订阅pubsub主题时，应用程序可以定义一个consumerID，这个ID决定了订阅者在队列或主题中的位置。利用StatefulSets中Pod的固定身份，您可以为每个Pod分配一个唯一的consumerID，从而实现订阅者应用程序的水平扩展。Dapr会跟踪每个Pod的名称，并可以在组件中使用{podName}标记来声明。

当扩展某个主题的订阅者数量时，每个Dapr组件都有特定的设置来决定其行为。通常，对于多个消费者有两种选择：

广播：发布到主题的每条消息将被所有订阅者接收。
共享：一条消息仅由一个订阅者接收（而不是所有订阅者）。

Kafka通过consumerID为每个订阅者分配独立的位置。当实例重新启动时，它会使用相同的consumerID继续从上次的位置处理消息，而不会遗漏任何消息。以下组件示例展示了如何让多个Pod使用Kafka组件：

限制 Pub/sub 主题访问

Mon, 01 Jan 0001 00:00:00 +0000

介绍

命名空间或组件范围可以用来限制组件的访问权限，使其仅对特定应用程序可用。这些应用程序范围的设置确保只有具有特定 ID 的应用程序才能使用该组件。

除了这种通用的组件范围外，还可以对 pub/sub 组件进行以下限制：

哪些主题可以被使用（发布或订阅）
哪些应用程序被允许发布到特定主题
哪些应用程序被允许订阅特定主题

这被称为 pub/sub 主题范围控制。

为每个 pub/sub 组件定义 pub/sub 范围。您可能有一个名为 pubsub 的 pub/sub 组件，它有一组范围，另一个 pubsub2 则有不同的范围。

要使用此主题范围，可以为 pub/sub 组件设置三个元数据属性：

spec.metadata.publishingScopes
- 一个以分号分隔的应用程序列表和以逗号分隔的主题列表，允许该应用程序发布到该主题列表
- 如果在 publishingScopes 中未指定任何内容（默认行为），则所有应用程序都可以发布到所有主题
- 要拒绝应用程序发布到任何主题的能力，请将主题列表留空（app1=;app2=topic2）
- 例如，app1=topic1;app2=topic2,topic3;app3= 将允许 app1 仅发布到 topic1，app2 仅发布到 topic2 和 topic3，app3 则不能发布到任何主题。
spec.metadata.subscriptionScopes
- 一个以分号分隔的应用程序列表和以逗号分隔的主题列表，允许该应用程序订阅该主题列表
- 如果在 subscriptionScopes 中未指定任何内容（默认行为），则所有应用程序都可以订阅所有主题
- 例如，app1=topic1;app2=topic2,topic3 将允许 app1 仅订阅 topic1，app2 仅订阅 topic2 和 topic3
spec.metadata.allowedTopics
- 一个为所有应用程序允许的主题的逗号分隔列表。
- 如果未设置 allowedTopics（默认行为），则所有主题都是有效的。如果存在，subscriptionScopes 和 publishingScopes 仍然生效。
- publishingScopes 或 subscriptionScopes 可以与 allowedTopics 结合使用以添加细粒度限制
spec.metadata.protectedTopics
- 一个为所有应用程序保护的主题的逗号分隔列表。
- 如果一个主题被标记为保护，则必须通过 publishingScopes 或 subscriptionScopes 明确授予应用程序发布或订阅权限才能发布/订阅该主题。

这些元数据属性可用于所有 pub/sub 组件。以下示例使用 Redis 作为 pub/sub 组件。

消息生存时间 (TTL)

Mon, 01 Jan 0001 00:00:00 +0000

介绍

Dapr 支持为每条消息设置生存时间 (TTL)。这意味着应用程序可以为每条消息指定生存时间，过期后订阅者将不会收到这些消息。

所有 Dapr 发布/订阅组件都兼容消息 TTL，因为 Dapr 在运行时内处理 TTL 逻辑。只需在发布消息时设置 ttlInSeconds 元数据即可。

在某些组件中，例如 Kafka，可以通过 retention.ms 在主题中配置生存时间，详见文档。使用 Dapr 的消息 TTL，使用 Kafka 的应用程序现在可以为每条消息设置生存时间，而不仅限于每个主题。

原生消息 TTL 支持

当发布/订阅组件原生支持消息生存时间时，Dapr 仅转发生存时间配置而不添加额外逻辑，保持行为的可预测性。这在组件以不同方式处理过期消息时非常有用。例如，在 Azure Service Bus 中，过期消息会被存储在死信队列中，而不是简单地删除。

注意

您还可以在创建时为给定的消息代理设置消息 TTL。查看您正在使用的组件的特定特性，以确定这是否合适。

支持的组件

Azure Service Bus

Azure Service Bus 支持实体级别的生存时间。这意味着消息有默认的生存时间，但也可以在发布时设置为更短的时间跨度。Dapr 传播消息的生存时间元数据，并让 Azure Service Bus 直接处理过期。

非 Dapr 订阅者

如果消息由不使用 Dapr 的订阅者消费，过期消息不会自动丢弃，因为过期是由 Dapr 运行时在 Dapr sidecar 接收到消息时处理的。然而，订阅者可以通过在云事件中添加逻辑来处理 expiration 属性，以编程方式丢弃过期消息，该属性遵循 RFC3339 格式。

当非 Dapr 订阅者使用诸如 Azure Service Bus 等原生处理消息 TTL 的组件时，他们不会收到过期消息。在这种情况下，不需要额外的逻辑。

批量发布和订阅消息

Mon, 01 Jan 0001 00:00:00 +0000

alpha

批量发布和订阅API目前处于alpha阶段。

通过批量发布和订阅API，您可以在单个请求中发布和订阅多个消息。在开发需要发送或接收大量消息的应用程序时，使用批量操作可以通过减少Dapr sidecar、应用程序和底层pubsub代理之间的请求总数来提高吞吐量。

批量发布消息

批量发布消息时的限制

批量发布API允许您通过单个请求将多个消息发布到一个主题。它是非事务性的，这意味着在一个批量请求中，某些消息可能会成功发布，而某些可能会失败。如果有消息发布失败，批量发布操作将返回失败消息的列表。

批量发布操作不保证消息的顺序。

示例

import io.dapr.client.DaprClientBuilder;
import io.dapr.client.DaprPreviewClient;
import io.dapr.client.domain.BulkPublishResponse;
import io.dapr.client.domain.BulkPublishResponseFailedEntry;
import java.util.ArrayList;
import java.util.List;

class BulkPublisher {
 private static final String PUBSUB_NAME = "my-pubsub-name";
 private static final String TOPIC_NAME = "topic-a";

 public void publishMessages() {
 try (DaprPreviewClient client = (new DaprClientBuilder()).buildPreviewClient()) {
 // 创建要发布的消息列表
 List<String> messages = new ArrayList<>();
 for (int i = 0; i < 10; i++) {
 String message = String.format("这是消息 #%d", i);
 messages.add(message);
 }

 // 使用批量发布API发布消息列表
 BulkPublishResponse<String> res = client.publishEvents(PUBSUB_NAME, TOPIC_NAME, "text/plain", messages).block();
 }
 }
}


import { DaprClient } from "@dapr/dapr";

const pubSubName = "my-pubsub-name";
const topic = "topic-a";

async function start() {
 const client = new DaprClient();

 // 向主题发布多个消息。
 await client.pubsub.publishBulk(pubSubName, topic, ["message 1", "message 2", "message 3"]);

 // 使用显式批量发布消息向主题发布多个消息。
 const bulkPublishMessages = [
 {
 entryID: "entry-1",
 contentType: "application/json",
 event: { hello: "foo message 1" },
 },
 {
 entryID: "entry-2",
 contentType: "application/cloudevents+json",
 event: {
 specversion: "1.0",
 source: "/some/source",
 type: "example",
 id: "1234",
 data: "foo message 2",
 datacontenttype: "text/plain"
 },
 },
 {
 entryID: "entry-3",
 contentType: "text/plain",
 event: "foo message 3",
 },
 ];
 await client.pubsub.publishBulk(pubSubName, topic, bulkPublishMessages);
}

start().catch((e) => {
 console.error(e);
 process.exit(1);
});

using System;
using System.Collections.Generic;
using Dapr.Client;

const string PubsubName = "my-pubsub-name";
const string TopicName = "topic-a";
IReadOnlyList<object> BulkPublishData = new List<object>() {
 new { Id = "17", Amount = 10m },
 new { Id = "18", Amount = 20m },
 new { Id = "19", Amount = 30m }
};

using var client = new DaprClientBuilder().Build();

var res = await client.BulkPublishEventAsync(PubsubName, TopicName, BulkPublishData);
if (res == null) {
 throw new Exception("从dapr返回的响应为空");
}
if (res.FailedEntries.Count > 0)
{
 Console.WriteLine("某些事件发布失败！");
 foreach (var failedEntry in res.FailedEntries)
 {
 Console.WriteLine("EntryId: " + failedEntry.Entry.EntryId + " 错误信息: " +
 failedEntry.ErrorMessage);
 }
}
else
{
 Console.WriteLine("所有事件已发布！");
}

import requests
import json

base_url = "http://localhost:3500/v1.0-alpha1/publish/bulk/{}/{}"
pubsub_name = "my-pubsub-name"
topic_name = "topic-a"
payload = [
 {
 "entryId": "ae6bf7c6-4af2-11ed-b878-0242ac120002",
 "event": "first text message",
 "contentType": "text/plain"
 },
 {
 "entryId": "b1f40bd6-4af2-11ed-b878-0242ac120002",
 "event": {
 "message": "second JSON message"
 },
 "contentType": "application/json"
 }
]

response = requests.post(base_url.format(pubsub_name, topic_name), json=payload)
print(response.status_code)

package main

import (
 "fmt"
 "strings"
 "net/http"
 "io/ioutil"
)

const (
 pubsubName = "my-pubsub-name"
 topicName = "topic-a"
 baseUrl = "http://localhost:3500/v1.0-alpha1/publish/bulk/%s/%s"
)

func main() {
 url := fmt.Sprintf(baseUrl, pubsubName, topicName)
 method := "POST"
 payload := strings.NewReader(`[
 {
 "entryId": "ae6bf7c6-4af2-11ed-b878-0242ac120002",
 "event": "first text message",
 "contentType": "text/plain"
 },
 {
 "entryId": "b1f40bd6-4af2-11ed-b878-0242ac120002",
 "event": {
 "message": "second JSON message"
 },
 "contentType": "application/json"
 }
]`)

 client := &http.Client {}
 req, _ := http.NewRequest(method, url, payload)

 req.Header.Add("Content-Type", "application/json")
 res, err := client.Do(req)
 // ...
}

curl -X POST http://localhost:3500/v1.0-alpha1/publish/bulk/my-pubsub-name/topic-a \
 -H 'Content-Type: application/json' \
 -d '[
 {
 "entryId": "ae6bf7c6-4af2-11ed-b878-0242ac120002",
 "event": "first text message",
 "contentType": "text/plain"
 },
 {
 "entryId": "b1f40bd6-4af2-11ed-b878-0242ac120002",
 "event": {
 "message": "second JSON message"
 },
 "contentType": "application/json"
 },
 ]'

Invoke-RestMethod -Method Post -ContentType 'application/json' -Uri 'http://localhost:3500/v1.0-alpha1/publish/bulk/my-pubsub-name/topic-a' `
-Body '[
 {
 "entryId": "ae6bf7c6-4af2-11ed-b878-0242ac120002",
 "event": "first text message",
 "contentType": "text/plain"
 },
 {
 "entryId": "b1f40bd6-4af2-11ed-b878-0242ac120002",
 "event": {
 "message": "second JSON message"
 },
 "contentType": "application/json"
 },
 ]'

批量订阅消息

批量订阅API允许您在单个请求中从一个主题订阅多个消息。正如我们从如何：发布和订阅主题中所知，有三种方式可以订阅主题：