This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

绑定组件规格

与 Dapr 交互的支持的外部绑定

1: Alibaba Cloud DingTalk binding 规范
2: Alibaba Cloud Tablestore binding 规范
3: Apple Push Notification Service 绑定规范
4: AWS DynamoDB 绑定规范
5: AWS Kinesis 绑定规范
6: AWS S3 绑定规范
7: AWS SES 绑定规范
8: AWS SNS 绑定规范
9: AWS SQS 绑定规范
10: Azure Blob Storage 绑定规范
11: Azure Cosmos DB (Gremlin API) 绑定规范
12: Azure Cosmos DB (SQL API) 绑定规范
13: Azure Event Grid 绑定规范
14: Azure Event Hubs 绑定规约
15: Azure OpenAI binding 规范
16: Azure Service Bus Queues 绑定规范
17: Azure SignalR 绑定规范
18: Azure Storage Queues binding spec
19: Cloudflare Queues 绑定规范
20: commercetools GraphQL 绑定规范
21: Cron 绑定规范
22: Apache Dubbo binding 规范
23: GCP Pub/Sub 绑定规范
24: GCP Storage Bucket binding 规范
25: GraphQL 绑定规范
26: HTTP binding 规范
27: Huawei OBS binding 规范
28: InfluxDB 绑定规范
29: Kafka 绑定规范
30: Kitex
31: KubeMQ 绑定规范
32: Kubernetes Events 绑定规范
33: Local Storage 绑定规范
34: MQTT3 binding 规范
35: MySQL & MariaDB 绑定规范
36: PostgreSQL 绑定规范
37: Postmark binding 规范
38: RabbitMQ 绑定规范
39: Redis binding spec
40: RethinkDB 绑定规范
41: Apache RocketMQ binding 规范
42: SFTP binding spec
43: SMTP 绑接规范
44: Twilio SendGrid binding spec
45: Twilio SMS 绑定规范
46: Wasm
47: Zeebe command binding 规范
48: Zeebe JobWorker 绑定规范
49: 阿里云对象存储服务绑定规范
50: 阿里云日志服务绑定规范

下表列出了 Dapr 绑定构建块支持的输入和输出绑定。了解如何为 Dapr 绑定设置不同的输入和输出绑定组件。

Table headers to note:

Header	Description	Example
Status	Component certification status	Alpha Beta Stable
Component version	The version of the component	v1
Since runtime version	The version of the Dapr runtime when the component status was set or updated	1.11

每个绑定组件都有自己的一组属性。点击名称链接以查看每个绑定的组件规格。

Generic

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
Apache Dubbo		✅	Alpha	v1	1.7
Apple Push Notifications (APN)		✅	Alpha	v1	1.0
commercetools GraphQL		✅	Alpha	v1	1.8
Cron (Scheduler)	✅		Stable	v1	1.10
GraphQL		✅	Alpha	v1	1.0
HTTP		✅	Stable	v1	1.0
Huawei OBS		✅	Alpha	v1	1.8
InfluxDB		✅	Beta	v1	1.7
Kafka	✅	✅	Stable	v1	1.8
Kitex		✅	Alpha	v1	1.11
KubeMQ	✅	✅	Beta	v1	1.10
Kubernetes Events	✅		Alpha	v1	1.0
Local Storage		✅	Stable	v1	1.9
MQTT3	✅	✅	Beta	v1	1.7
MySQL & MariaDB		✅	Alpha	v1	1.0
PostgreSQL		✅	Stable	v1	1.9
Postmark		✅	Alpha	v1	1.0
RabbitMQ	✅	✅	Stable	v1	1.9
Redis		✅	Stable	v1	1.9
RethinkDB	✅		Beta	v1	1.9
RocketMQ	✅	✅	Alpha	v1	1.2
SFTP		✅	Alpha	v1	1.15
SMTP		✅	Alpha	v1	1.0
Twilio SMS		✅	Alpha	v1	1.0
Twillio SendGrid		✅	Alpha	v1	1.0
Wasm		✅	Alpha	v1	1.11

Alibaba Cloud

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
Alibaba Cloud DingTalk	✅	✅	Alpha	v1	1.2
Alibaba Cloud OSS		✅	Alpha	v1	1.0
Alibaba Cloud SLS		✅	Alpha	v1	1.9
Alibaba Cloud Tablestore		✅	Alpha	v1	1.5

Amazon Web Services (AWS)

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
AWS DynamoDB		✅	Alpha	v1	1.0
AWS Kinesis	✅	✅	Alpha	v1	1.0
AWS S3		✅	Stable	v1	1.11
AWS SES		✅	Alpha	v1	1.4
AWS SNS		✅	Alpha	v1	1.0
AWS SQS	✅	✅	Alpha	v1	1.0

Cloudflare

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
Cloudflare Queues		✅	Alpha	v1	1.10

Google Cloud Platform (GCP)

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
GCP Cloud Pub/Sub	✅	✅	Alpha	v1	1.0
GCP Storage Bucket		✅	Alpha	v1	1.0

Microsoft Azure

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
Azure Blob Storage		✅	Stable	v1	1.0
Azure Cosmos DB (Gremlin API)		✅	Alpha	v1	1.5
Azure CosmosDB		✅	Stable	v1	1.7
Azure Event Grid	✅	✅	Beta	v1	1.7
Azure Event Hubs	✅	✅	Stable	v1	1.8
Azure OpenAI	✅	✅	Alpha	v1	1.11
Azure Service Bus Queues	✅	✅	Stable	v1	1.7
Azure SignalR		✅	Alpha	v1	1.0
Azure Storage Queues	✅	✅	Stable	v1	1.0

Zeebe (Camunda Cloud)

Component	Input Binding	Output Binding	Status	Component version	Since runtime version
Zeebe Command		✅	Stable	v1	1.2
Zeebe Job Worker	✅		Stable	v1	1.2

1 - Alibaba Cloud DingTalk binding 规范

Alibaba Cloud DingTalk binding 组件的详细文档

设置 Dapr 组件

要设置 Alibaba Cloud DingTalk binding，请创建一个类型为 bindings.dingtalk.webhook 的组件。有关如何创建和应用 secretstore 配置，请参阅此指南。有关如何检索和使用密钥以及 Dapr 组件，请参阅此引用密钥指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.dingtalk.webhook
  version: v1
  metadata:
  - name: id
    value: "test_webhook_id"
  - name: url
    value: "https://oapi.dingtalk.com/robot/send?access_token=******"
  - name: secret
    value: "****************"
  - name: direction
    value: "input, output"

Warning

上面的示例将密钥作为纯字符串使用。建议使用密钥存储来存储密钥，如此处所述。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`id`	Y	Input/Output	唯一 id	`"test_webhook_id"`
`url`	Y	Input/Output	DingTalk 的 Webhook url	`"https://oapi.dingtalk.com/robot/send?access_token=******"`
`secret`	N	Input/Output	DingTalk Webhook 的密钥	`"****************"`
`direction`	N	Input/Output	binding 的方向	`"input"`, `"output"`, `"input, output"`

Binding 支持

此组件支持输入和输出 binding 接口。

此组件支持输出 binding，具有以下操作：

create
get

指定负载

示例：按照此处的说明设置负载数据

curl -X POST http://localhost:3500/v1.0/bindings/myDingTalk \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "msgtype": "text",
          "text": {
            "content": "Hi"
          }
        },
        "operation": "create"
      }'

curl -X POST http://localhost:3500/v1.0/bindings/myDingTalk \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "msgtype": "text",
          "text": {
            "content": "Hi"
          }
        },
        "operation": "get"
      }'

2 - Alibaba Cloud Tablestore binding 规范

Alibaba Tablestore binding 组件的详细文档

组件格式

要设置 Alibaba Cloud Tablestore binding，请创建类型为 bindings.alicloud.tablestore 的组件。有关如何创建和应用 secretstore 配置，请参阅本指南。有关如何使用 Dapr 组件检索和使用密钥，请参阅引用密钥指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: mytablestore
spec:
  type: bindings.alicloud.tablestore
  version: v1
  metadata:
  - name: endpoint
    value: "[endpoint]"
  - name: accessKeyID
    value: "[key-id]"
  - name: accessKey
    value: "[access-key]"
  - name: instanceName
    value: "[instance]"
  - name: tableName
    value: "[table]"
  - name: endpoint
    value: "[endpoint]"

Warning

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体如此处所述。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`endpoint`	Y	Output	Alicloud Tablestore 端点。	https://tablestore-cn-hangzhou.aliyuncs.com
`accessKeyID`	Y	Output	Access key ID 凭证。
`accessKey`	Y	Output	Access key 凭证。
`instanceName`	Y	Output	实例名称。
`tableName`	Y	Output	表名称。

Binding 支持

此组件支持输出 binding，具有以下操作：

create：创建对象

创建对象

要执行创建对象操作，请使用 POST 方法调用 binding，并传入以下 JSON 正文：

{
  "operation": "create",
  "data": "YOUR_CONTENT",
  "metadata": {
    "primaryKeys": "pk1"
  }
}

Note

注意 metadata.primaryKeys 字段是必填项。

删除对象

要执行删除对象操作，请使用 POST 方法调用 binding，并传入以下 JSON 正文：

{
  "operation": "delete",
  "metadata": {
   "primaryKeys": "pk1",
   "columnToGet": "name,age,date"
  },
  "data": {
    "pk1": "data1"
  }
}

Note

注意 metadata.primaryKeys 字段是必填项。

列出对象

要执行列出对象操作，请使用 POST 方法调用 binding，并传入以下 JSON 正文：

{
  "operation": "delete",
  "metadata": {
    "primaryKeys": "pk1",
    "columnToGet": "name,age,date"
  },
  "data": {
    "pk1": "data1",
    "pk2": "data2"
  }
}

Note

注意 metadata.primaryKeys 字段是必填项。

获取对象

要执行获取对象操作，请使用 POST 方法调用 binding，并传入以下 JSON 正文：

{
  "operation": "delete",
  "metadata": {
    "primaryKeys": "pk1"
  },
  "data": {
    "pk1": "data1"
  }
}

Note

注意 metadata.primaryKeys 字段是必填项。

3 - Apple Push Notification Service 绑定规范

Apple Push Notification Service 绑定组件的详细文档

组件格式

要设置 Apple Push Notifications 绑定，请创建类型为 bindings.apns 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.apns
  version: v1
  metadata:
    - name: development
      value: "<bool>"
    - name: key-id
      value: "<APPLE_KEY_ID>"
    - name: team-id
      value: "<APPLE_TEAM_ID>"
    - name: private-key
      secretKeyRef:
        name: <SECRET>
        key: "<SECRET-KEY-NAME>"

规格元数据字段

字段	必填	绑定支持	详情	示例
`development`	Y	Output	告诉绑定使用哪个 APNs 服务。设置为 `"true"` 以使用开发服务，或设置为 `"false"` 以使用生产服务。默认值：`"true"`	`"true"`
`key-id`	Y	Output	来自 Apple Developer Portal 的私钥标识符	`"private-key-id`"
`team-id`	Y	Output	来自 Apple Developer Portal 的组织或作者标识符	`"team-id"`
`private-key`	Y	Output	是一个 PKCS #8 格式的私钥。私钥应存储在 secret store 中，而不是直接暴露在配置中。有关更多详细信息，请参阅此处	`"pem file"`

私钥

APNS 绑定需要一个加密私钥来为 APNS 服务生成认证令牌。私钥可以从 Apple Developer Portal 生成，以 PKCS #8 文件的形式提供，私钥以 PEM 格式存储。私钥应存储在 Dapr secret store 中，而不是直接存储在绑定配置文件中。

下面显示了 APNS 绑定的示例配置文件：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: apns
spec:
  type: bindings.apns
  metadata:
  - name: development
    value: false
  - name: key-id
    value: PUT-KEY-ID-HERE
  - name: team-id
    value: PUT-APPLE-TEAM-ID-HERE
  - name: private-key
    secretKeyRef:
      name: apns-secrets
      key: private-key

如果使用 Kubernetes，示例 secret 配置可能如下所示：

apiVersion: v1
kind: Secret
metadata:
    name: apns-secrets
stringData:
    private-key: |
        -----BEGIN PRIVATE KEY-----
        KEY-DATA-GOES-HERE
        -----END PRIVATE KEY-----

绑定支持

此组件支持 输出绑定，具有以下操作：

create

推送通知格式

APNS 绑定是对 Apple Push Notification Service 的透传包装器。APNS 绑定将直接向 APNS 服务发送请求，而不进行任何转换。因此，了解 APNS 服务期望的推送通知负载格式非常重要。负载格式记录在此处。

请求格式

{
    "data": {
        "aps": {
            "alert": {
                "title": "New Updates!",
                "body": "There are new updates for your review"
            }
        }
    },
    "metadata": {
        "device-token": "PUT-DEVICE-TOKEN-HERE",
        "apns-push-type": "alert",
        "apns-priority": "10",
        "apns-topic": "com.example.helloworld"
    },
    "operation": "create"
}

data 对象包含完整的推送通知规范，如 Apple 文档中所述。data 对象将直接发送到 APNs 服务。

除了 device-token 值之外，Apple 文档中指定的 HTTP 标头可以作为元数据字段发送，并将包含在对 APNs 服务的 HTTP 请求中。

响应格式

{
    "messageID": "UNIQUE-ID-FOR-NOTIFICATION"
}

4 - AWS DynamoDB 绑定规范

AWS DynamoDB 绑定组件的详细文档

组件格式

要设置 AWS DynamoDB 绑定，请创建类型为 bindings.aws.dynamodb 的组件。有关如何创建和应用绑定配置，请参阅此指南。

有关身份验证相关属性的信息，请参阅向 AWS 进行身份验证

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.dynamodb
  version: v1
  metadata:
  - name: table
    value: "items"
  - name: region
    value: "us-west-2"
  - name: accessKey
    value: "*****************"
  - name: secretKey
    value: "*****************"
  - name: sessionToken
    value: "*****************"

Warning

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`table`	Y	Output	DynamoDB 表名	`"items"`
`region`	Y	Output	AWS DynamoDB 实例部署所在的特定 AWS 区域	`"us-east-1"`
`accessKey`	Y	Output	用于访问此资源的 AWS 访问密钥	`"key"`
`secretKey`	Y	Output	用于访问此资源的 AWS 秘密访问密钥	`"secretAccessKey"`
`sessionToken`	N	Output	要使用的 AWS 会话令牌	`"sessionToken"`

Important

当在 EKS (AWS Kubernetes) 上与您的应用程序一起运行 Dapr 边车 (daprd) 时，如果您使用的节点/pod 已经附加了定义对 AWS 资源访问权限的 IAM 策略，则不得在您使用的组件规范定义中提供 AWS 访问密钥、秘密密钥和令牌。

绑定支持

此组件支持输出绑定，具有以下操作：

create

5 - AWS Kinesis 绑定规范

AWS Kinesis 绑定组件的详细文档

组件格式

要设置 AWS Kinesis 绑定，请创建一个类型为 bindings.aws.kinesis 的组件。有关如何创建和应用绑定配置，请参阅本指南。

有关如何设置 AWS Kinesis 数据流的说明，请参阅此有关身份验证相关属性的信息，请参阅向 AWS 进行身份验证

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.kinesis
  version: v1
  metadata:
  - name: streamName
    value: "KINESIS_STREAM_NAME" # Kinesis 流名称
  - name: consumerName
    value: "KINESIS_CONSUMER_NAME" # Kinesis 消费者名称
  - name: mode
    value: "shared" # shared - 共享吞吐量 或 extended - 扩展/增强扇出
  - name: region
    value: "AWS_REGION" # 替换
  - name: accessKey
    value: "AWS_ACCESS_KEY" # 替换
  - name: secretKey
    value: "AWS_SECRET_KEY" # 替换
  - name: sessionToken
    value: "*****************"
  - name: direction
    value: "input, output"
  - name: endpoint
    value: "http://localhost:4566" # 可选：自定义端点（例如用于 LocalStack）

警告

上述示例使用纯文本字符串作为密钥。建议使用密钥存储来管理密钥，如此处所述。

规范元数据字段

字段	必填	绑定支持	详情	示例
`mode`	N	输入	Kinesis 流模式。`shared`- 共享吞吐量，`extended` - 扩展/增强扇出方法。更多细节请见这里。默认为 `"shared"`	`"shared"`, `"extended"`
`streamName`	Y	输入/输出	AWS Kinesis 流名称	`"stream"`
`consumerName`	Y	输入	AWS Kinesis 消费者名称	`"myconsumer"`
`region`	Y	输出	AWS Kinesis 实例部署的特定 AWS 区域	`"us-east-1"`
`accessKey`	Y	输出	用于访问此资源的 AWS 访问密钥	`"key"`
`secretKey`	Y	输出	用于访问此资源的 AWS 秘密访问密钥	`"secretAccessKey"`
`sessionToken`	N	输出	要使用的 AWS 会话令牌	`"sessionToken"`
`direction`	N	输入/输出	绑定的方向	`"input"`, `"output"`, `"input, output"`
`endpoint`	N	输入	Kinesis 和 DynamoDB 的自定义端点（例如启用 AWS LocalStack 支持）	`"http://localhost:4566"`

重要

在 EKS (AWS Kubernetes) 上与应用程序一起运行 Dapr 边车 (daprd) 时，如果您使用的节点/Pod 已附加到定义访问 AWS 资源的 IAM 策略，则不得在您使用的组件规范定义中提供 AWS 访问密钥、秘密密钥和令牌。

绑定支持

此组件支持输入和输出绑定接口。

此组件支持以下操作的输出绑定：

create

6 - AWS S3 绑定规范

AWS S3 绑定组件的详细文档

组件格式

要设置 AWS S3 绑定，请创建一个类型为 bindings.aws.s3 的组件。该绑定适用于其他兼容 S3 的服务，例如 Minio。有关如何创建和应用绑定配置，请参阅此指南。

有关身份验证相关属性的信息，请参阅向 AWS 进行身份验证。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.s3
  version: v1
  metadata:
  - name: bucket
    value: "mybucket"
  - name: region
    value: "us-west-2"
  - name: endpoint
    value: "s3.us-west-2.amazonaws.com"
  - name: accessKey
    value: "*****************"
  - name: secretKey
    value: "*****************"
  - name: sessionToken
    value: "mysession"
  - name: decodeBase64
    value: "<bool>"
  - name: encodeBase64
    value: "<bool>"
  - name: forcePathStyle
    value: "<bool>"
  - name: disableSSL
    value: "<bool>"
  - name: insecureSSL
    value: "<bool>"
  - name: storageClass
    value: "<string>"

警告

上述示例将密钥以纯字符串形式使用。建议按照此处的说明使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`bucket`	Y	Output	要写入的 S3 存储桶名称	`"bucket"`
`region`	Y	Output	特定的 AWS 区域	`"us-east-1"`
`endpoint`	N	Output	特定的 AWS 端点	`"s3.us-east-1.amazonaws.com"`
`accessKey`	Y	Output	用于访问此资源的 AWS 访问密钥	`"key"`
`secretKey`	Y	Output	用于访问此资源的 AWS 秘密访问密钥	`"secretAccessKey"`
`sessionToken`	N	Output	要使用的 AWS 会话令牌	`"sessionToken"`
`forcePathStyle`	N	Output	目前 Amazon S3 SDK 支持虚拟托管式和路径式访问。`"true"` 为路径式格式，如 `"https://<endpoint>/<your bucket>/<key>"`。`"false"` 为托管式格式，如 `"https://<your bucket>.<endpoint>/<key>"`。默认为 `"false"`	`"true"`, `"false"`
`decodeBase64`	N	Output	在保存到存储桶之前解码 base64 文件内容的配置。（用于保存包含二进制内容的文件）。`"true"` 是唯一允许的肯定值。其他肯定变体如 `"True"`, `"1"` 不可接受。默认为 `false`	`"true"`, `"false"`
`encodeBase64`	N	Output	在返回内容之前编码 base64 文件内容的配置。（用于打开包含二进制内容的文件）。`"true"` 是唯一允许的肯定值。其他肯定变体如 `"True"`, `"1"` 不可接受。默认为 `"false"`	`"true"`, `"false"`
`disableSSL`	N	Output	允许连接到非 `https://` 端点。默认为 `"false"`	`"true"`, `"false"`
`insecureSSL`	N	Output	当连接到 `https://` 端点时，接受无效或自签名证书。默认为 `"false"`	`"true"`, `"false"`
`storageClass`	N	Output	创建操作期间对象的所需存储类。有效的 AWS 存储类类型可在此处找到	`STANDARD_IA`

重要

在 EKS (AWS Kubernetes) 上将 Dapr 边车 (daprd) 与您的应用程序一起运行时，如果您使用的节点/Pod 已附加到定义 AWS 资源访问权限的 IAM 策略，则不得在正在使用的组件规范定义中提供 AWS 访问密钥、秘密密钥和令牌。

S3 存储桶创建

与 Minio 一起使用

Minio 是一项将本地存储暴露为兼容 S3 的块存储的服务，它是 S3 的流行替代方案，尤其是在开发环境中。您也可以将 S3 绑定与 Minio 一起使用，只需进行一些配置调整：

将 endpoint 设置为 Minio 服务器的地址，包括协议（http:// 或 https://）和末尾的可选端口。例如，http://minio.local:9000（具体值取决于您的环境）。
forcePathStyle 必须设置为 true
region 的值不重要；您可以将其设置为 us-east-1。
根据您的环境，如果您使用非安全连接（使用 http:// 协议）连接到 Minio，可能需要将 disableSSL 设置为 true。如果您使用安全连接（https:// 协议）但使用自签名证书，则可能需要将 insecureSSL 设置为 true。

对于本地开发，使用 LocalStack 项目来集成 AWS S3。按照这些说明运行 LocalStack。

要使用 Docker 从命令行在本地运行 LocalStack，请使用类似于以下的 docker-compose.yaml：

version: "3.8"

services:
  localstack:
    container_name: "cont-aws-s3"
    image: localstack/localstack:1.4.0
    ports:
      - "127.0.0.1:4566:4566"
    environment:
      - DEBUG=1
      - DOCKER_HOST=unix:///var/run/docker.sock
    volumes:
      - "<PATH>/init-aws.sh:/etc/localstack/init/ready.d/init-aws.sh"  # init hook
      - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

要使用 S3 组件，您需要使用现有的存储桶。上述示例使用 LocalStack 初始化钩子来设置存储桶。

要将 LocalStack 与 S3 绑定一起使用，您需要在组件元数据中提供 endpoint 配置。当针对生产 AWS 运行时，不需要 endpoint。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
    name: aws-s3
    namespace: default
spec:
  type: bindings.aws.s3
  version: v1
  metadata:
    - name: bucket
      value: conformance-test-docker
    - name: endpoint
      value: "http://localhost:4566"
    - name: accessKey
      value: "my-access"
    - name: secretKey
      value: "my-secret"
    - name: region
      value: "us-east-1"

要使用 S3 组件，您需要使用现有的存储桶。按照 AWS 文档创建存储桶。

绑定支持

该组件支持具有以下操作的输出绑定：

create : 创建对象
get : 获取对象
delete : 删除对象
list: 列出对象

创建对象

要执行创建操作，请使用 POST 方法调用 AWS S3 绑定，并提供以下 JSON 请求体：

注意：默认情况下，会生成一个随机 UUID。有关设置名称的元数据支持，请参阅下文

{
  "operation": "create",
  "data": "YOUR_CONTENT",
  "metadata": { 
    "storageClass": "STANDARD_IA",
    "tags": "project=sashimi,year=2024",
  }
}

例如，您可以在使用 Linux curl 命令执行 create 操作时提供存储类或标签

curl -d '{ "operation": "create", "data": "YOUR_BASE_64_CONTENT", "metadata": { "storageClass": "STANDARD_IA", "project=sashimi,year=2024" } }' /
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

使用预签名 URL 共享对象

要为对象指定生存时间进行预签名，请在 create 请求上使用 presignTTL 元数据键。 presignTTL 的有效值为 Go duration 字符串。

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"presignTTL\": \"15m\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "presignTTL": "15m" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下示例 JSON：

{
    "location":"https://<your bucket>.s3.<your region>.amazonaws.com/<key>",
    "versionID":"<version ID if Bucket Versioning is enabled>",
    "presignURL": "https://<your bucket>.s3.<your region>.amazonaws.com/image.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJJWZ7B6WCRGMKFGQ%2F20180210%2Feu-west-2%2Fs3%2Faws4_request&X-Amz-Date=20180210T171315Z&X-Amz-Expires=1800&X-Amz-Signature=12b74b0788aa036bc7c3d03b3f20c61f1f91cc9ad8873e3314255dc479a25351&X-Amz-SignedHeaders=host"
}

示例

将文本保存到随机生成的 UUID 文件

在 Windows 上，使用 cmd 提示符（PowerShell 具有不同的转义机制）

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文本保存到特定文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"key\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "key": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文件保存为对象

要上传文件，请将其编码为 Base64 并让绑定知道对其进行反序列化：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.s3
  version: v1
  metadata:
  - name: bucket
    value: mybucket
  - name: region
    value: us-west-2
  - name: endpoint
    value: s3.us-west-2.amazonaws.com
  - name: accessKey
    value: *****************
  - name: secretKey
    value: *****************
  - name: sessionToken
    value: mysession
  - name: decodeBase64
    value: <bool>
  - name: forcePathStyle
    value: <bool>

然后您可以像往常一样上传它：

curl -d "{ \"operation\": \"create\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"key\": \"my-test-file.jpg\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "YOUR_BASE_64_CONTENT", "metadata": { "key": "my-test-file.jpg" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

从文件路径上传

要从提供的路径（相对或绝对）上传文件，请在包含空 data 字段的 create 请求上使用 filepath 元数据键。

curl -d '{ \"operation\": \"create\", \"metadata\": { \"filePath\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "metadata": { "filePath": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体将包含以下 JSON：

{
    "location":"https://<your bucket>.s3.<your region>.amazonaws.com/<key>",
    "versionID":"<version ID if Bucket Versioning is enabled"
}

预签名现有对象

要为现有的 S3 对象指定生存时间进行预签名，请在 presign 请求上使用 presignTTL 和 key 元数据键。 presignTTL 的有效值为 Go duration 字符串。

curl -d "{ \"operation\": \"presign\", \"metadata\": { \"presignTTL\": \"15m\", \"key\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "presign", "metadata": { "presignTTL": "15m", "key": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下示例 JSON：

{
    "presignURL": "https://<your bucket>.s3.<your region>.amazonaws.com/image.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJJWZ7B6WCRGMKFGQ%2F20180210%2Feu-west-2%2Fs3%2Faws4_request&X-Amz-Date=20180210T171315Z&X-Amz-Expires=1800&X-Amz-Signature=12b74b0788aa036bc7c3d03b3f20c61f1f91cc9ad8873e3314255dc479a25351&X-Amz-SignedHeaders=host"
}

获取对象

要执行获取文件操作，请使用 POST 方法调用 AWS S3 绑定，并提供以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数为：

key - 对象的名称

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含存储在对象中的值。

删除对象

要执行删除对象操作，请使用 POST 方法调用 AWS S3 绑定，并提供以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数为：

key - 对象的名称

示例

删除对象

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

如果成功，将返回 HTTP 204（无内容）和空响应体。

列出对象

要执行列出对象操作，请使用 POST 方法调用 S3 绑定，并提供以下 JSON 请求体：

{
  "operation": "list",
  "data": {
    "maxResults": 10,
    "prefix": "file",
    "marker": "hvlcCQFSOD5TD",
    "delimiter": "i0FvxAn2EOEL6"
  }
}

数据参数为：

maxResults - （可选）设置响应中返回的键的最大数量。默认情况下，该操作最多返回 1,000 个键名称。响应可能包含较少的键，但绝不会包含更多。
prefix - （可选）将响应限制为以指定前缀开头的键。
marker - （可选）marker 是您希望 Amazon S3 开始列出的位置。Amazon S3 在此指定的键之后开始列出。Marker 可以是存储桶中的任何键。然后可以在后续调用中使用 marker 值来请求下一组列表项。
delimiter - （可选）分隔符是用于对键进行分组的字符。

响应

响应体包含找到的对象列表。

对象列表将以 JSON 数组形式返回，格式如下：

{
	"CommonPrefixes": null,
	"Contents": [
		{
			"ETag": "\"7e94cc9b0f5226557b05a7c2565dd09f\"",
			"Key": "hpNdFUxruNuwm",
			"LastModified": "2021-08-16T06:44:14Z",
			"Owner": {
				"DisplayName": "owner name",
				"ID": "owner id"
			},
			"Size": 6916,
			"StorageClass": "STANDARD"
		}
	],
	"Delimiter": "",
	"EncodingType": null,
	"IsTruncated": true,
	"Marker": "hvlcCQFSOD5TD",
	"MaxKeys": 1,
	"Name": "mybucketdapr",
	"NextMarker": "hzaUPWjmvyi9W",
	"Prefix": ""
}

7 - AWS SES 绑定规范

AWS SES 绑定组件的详细文档

组件格式

要设置 AWS 绑定，请创建类型为 bindings.aws.ses 的组件。请参阅本指南了解如何创建和应用绑定配置。

有关身份验证相关属性的信息，请参阅向 AWS 进行身份验证

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: ses
spec:
  type: bindings.aws.ses
  version: v1
  metadata:
  - name: accessKey
    value: *****************
  - name: secretKey
    value: *****************
  - name: region
    value: "eu-west-1"
  - name: sessionToken
    value: mysession
  - name: emailFrom
    value: "sender@example.com"
  - name: emailTo
    value: "receiver@example.com"
  - name: emailCc
    value: "cc@example.com"
  - name: emailBcc
    value: "bcc@example.com"
  - name: subject
    value: "subject"

Warning

上述示例将密钥作为纯文本字符串使用。建议按照此处所述使用密钥存储来管理密钥。

规范元数据字段

Field	Required	Binding support	Details	Example
`region`	N	Output	特定的 AWS 区域	`"eu-west-1"`
`accessKey`	N	Output	用于访问此资源的 AWS Access Key	`"key"`
`secretKey`	N	Output	用于访问此资源的 AWS Secret Access Key	`"secretAccessKey"`
`sessionToken`	N	Output	要使用的 AWS 会话令牌	`"sessionToken"`
`emailFrom`	N	Output	如果设置，指定发件人的电子邮件地址。另请参见示例	`"me@example.com"`
`emailTo`	N	Output	如果设置，指定收件人的电子邮件地址。另请参见示例	`"me@example.com"`
`emailCc`	N	Output	如果设置，指定要抄送的电子邮件地址。另请参见示例	`"me@example.com"`
`emailBcc`	N	Output	如果设置，指定要密送的电子邮件地址。另请参见示例	`"me@example.com"`
`subject`	N	Output	如果设置，指定电子邮件的主题。另请参见示例	`"subject of mail"`

Important

当在 EKS（AWS Kubernetes）上与应用程序一起运行 Dapr 边车（daprd）时，如果您使用的节点/Pod 已附加到定义了 AWS 资源访问权限的 IAM 策略，则绝不能在正在使用的组件规范定义中提供 AWS access-key、secret-key 和令牌。

绑定支持

此组件支持输出绑定，具有以下操作：

create

示例请求

您可以在每个请求中指定以下任意可选元数据属性：

emailFrom
emailTo
emailCc
emailBcc
subject

发送电子邮件时，配置和请求中的元数据会合并。合并后的元数据集必须至少包含 emailFrom、emailTo、emailCc、emailBcc 和 subject 字段。

emailTo、emailCc 和 emailBcc 字段可以包含多个用分号分隔的电子邮件地址。

示例：

{
  "operation": "create",
  "metadata": {
    "emailTo": "dapr-smtp-binding@example.net",
    "emailCc": "cc1@example.net",
    "subject": "Email subject"
  },
  "data": "Testing Dapr SMTP Binding"
}

emailTo、emailCc 和 emailBcc 字段可以包含多个用分号分隔的电子邮件地址。

8 - AWS SNS 绑定规范

AWS SNS 绑定组件的详细文档

组件格式

要设置 AWS SNS 绑定，需创建一个类型为 bindings.aws.sns 的组件。有关如何创建和应用绑定配置，请参阅此指南。

有关身份验证相关属性的信息，请参阅向 AWS 进行身份验证

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.sns
  version: v1
  metadata:
  - name: topicArn
    value: "mytopic"
  - name: region
    value: "us-west-2"
  - name: endpoint
    value: "sns.us-west-2.amazonaws.com"
  - name: accessKey
    value: "*****************"
  - name: secretKey
    value: "*****************"
  - name: sessionToken
    value: "*****************"

警告

上述示例将密钥作为纯字符串使用。建议按照此处所述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详细说明	示例
`topicArn`	Y	输出	SNS 主题名称	`"arn:::topicarn"`
`region`	Y	输出	特定的 AWS 区域	`"us-east-1"`
`endpoint`	N	输出	特定的 AWS 端点	`"sns.us-east-1.amazonaws.com"`
`accessKey`	Y	输出	用于访问此资源的 AWS 访问密钥	`"key"`
`secretKey`	Y	输出	用于访问此资源的 AWS 秘密访问密钥	`"secretAccessKey"`
`sessionToken`	N	输出	要使用的 AWS 会话令牌	`"sessionToken"`

重要

在 EKS（AWS Kubernetes）上与你的应用程序一起运行 Dapr 边车（daprd）时，如果你使用的节点/Pod 已附加到定义了 AWS 资源访问权限的 IAM 策略，则不得在你使用的组件规范定义中提供 AWS 访问密钥、秘密密钥和令牌。

绑定支持

此组件支持输出绑定，支持以下操作：

create

9 - AWS SQS 绑定规范

AWS SQS 绑定组件的详细文档

组件格式

要设置 AWS SQS 绑定，请创建一个类型为 bindings.aws.sqs 的组件。请参阅此指南了解如何创建和应用绑定配置。

请参阅向 AWS 进行身份验证了解与身份验证相关的属性信息

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.aws.sqs
  version: v1
  metadata:
  - name: queueName
    value: "items"
  - name: region
    value: "us-west-2"
  - name: endpoint
    value: "sqs.us-west-2.amazonaws.com"    
  - name: accessKey
    value: "*****************"
  - name: secretKey
    value: "*****************"
  - name: sessionToken
    value: "*****************"
  - name: direction 
    value: "input, output"

Warning

上述示例将密钥以纯文本字符串形式展示。建议按照此处说明使用密钥存储来管理敏感信息。

规范元数据字段

字段	必填	绑定支持	详情	示例
`queueName`	是	输入/输出	SQS 队列名称	`"myqueue"`
`region`	是	输入/输出	特定的 AWS 区域	`"us-east-1"`
`endpoint`	否	输出	特定的 AWS 端点	`"sqs.us-east-1.amazonaws.com"`
`accessKey`	是	输入/输出	用于访问此资源的 AWS 访问密钥	`"key"`
`secretKey`	是	输入/输出	用于访问此资源的 AWS 秘密访问密钥	`"secretAccessKey"`
`sessionToken`	否	输入/输出	要使用的 AWS 会话令牌	`"sessionToken"`
`direction`	否	输入/输出	绑定的方向	`"input"`, `"output"`, `"input, output"`

Important

当在 EKS（AWS Kubernetes）上使用 Dapr 边车（daprd）与应用程序一起运行时，如果您使用的节点/Pod 已附加定义了访问 AWS 资源的 IAM 策略，则不得在所使用的组件规范定义中提供 AWS 访问密钥、秘密密钥和令牌。

绑定支持

该组件同时支持输入和输出绑定接口。

该组件支持以下操作的输出绑定：

create

10 - Azure Blob Storage 绑定规范

Azure Blob Storage 绑定组件的详细文档

组件格式

若要设置 Azure Blob Storage 绑定，请创建类型为 bindings.azure.blobstorage 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.blobstorage
  version: v1
  metadata:
  - name: accountName
    value: myStorageAccountName
  - name: accountKey
    value: ***********
  - name: containerName
    value: container1
# - name: decodeBase64
#   value: <bool>
# - name: getBlobRetryCount
#   value: <integer>
# - name: publicAccessLevel
#   value: <publicAccessLevel>
# - name: disableEntityManagement
#   value: <bool>

Warning

上述示例将密钥以纯文本字符串形式使用。建议使用 secret store 来管理密钥，具体请参阅此处。

规范元数据字段

字段	必填	绑定支持	详情	示例
`accountName`	Y	Input/Output	Azure Storage 账户名称	`"myexmapleaccount"`
`accountKey`	Y*	Input/Output	Azure Storage 账户访问密钥。仅在不使用 Microsoft Entra ID 身份验证时需要。	`"access-key"`
`containerName`	Y	Output	要写入的 Blob Storage 容器名称	`myexamplecontainer`
`endpoint`	N	Input/Output	可选的自定义 endpoint URL。在使用 Azurite emulator 或为 Azure Storage 使用自定义域时（尽管这不属于官方支持场景）这很有用。endpoint 必须是完整的基础 URL，包含协议（`http://` 或 `https://`）、IP 或 FQDN 以及可选端口。	`"http://127.0.0.1:10000"`
`decodeBase64`	N	Output	在保存到 Blob Storage 之前对 base64 文件内容进行解码的配置（用于保存包含二进制内容的文件）。默认为 `false`	`true`、`false`
`getBlobRetryCount`	N	Output	指定在从 RetryReader 读取时最多发起的 HTTP GET 请求次数。默认为 `10`	`1`、`2`
`publicAccessLevel`	N	Output	指定容器中的数据是否可以公开访问以及访问级别（仅在容器由 Dapr 创建时使用）。默认为 `none`	`blob`、`container`、`none`
`disableEntityManagement`	N	Output	用于禁用实体管理的配置。设置为 `true` 时，绑定将跳过创建指定存储容器的尝试。在使用最小的 Azure AD 权限时这很有用。默认为 `false`	`true`、`false`

Microsoft Entra ID 身份验证

Azure Blob Storage 绑定组件支持使用所有 Microsoft Entra ID 机制进行身份验证。有关更多信息和根据所选的 Microsoft Entra ID 身份验证机制需要提供的组件元数据字段，请参阅对 Azure 进行身份验证的文档。

绑定支持

此组件支持输出绑定，包含以下操作：

create：创建 blob
get：获取 blob
delete：删除 blob
list：列出 blob

Blob storage 组件的输入绑定通过 Azure Event Grid 触发并推送事件。

有关更多设置和信息，请参阅响应 Blob storage 事件指南。

创建 blob

要执行创建 blob 操作，请使用 POST 方法调用 Azure Blob Storage 绑定，并使用以下 JSON 请求体：

注意：默认情况下会生成一个随机 UUID。有关设置名称的元数据支持，请参阅下文

{
  "operation": "create",
  "data": "YOUR_CONTENT"
}

示例

将文本保存到随机生成的 UUID blob

在 Windows 上，使用 cmd 提示符（PowerShell 具有不同的转义机制）

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文本保存到指定 blob

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"blobName\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "blobName": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文件保存到 blob

要上传文件，将其编码为 Base64 并让 Binding 知道需要反序列化：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.blobstorage
  version: v1
  metadata:
  - name: accountName
    value: myStorageAccountName
  - name: accountKey
    value: ***********
  - name: containerName
    value: container1
  - name: decodeBase64
    value: true

然后您可以像平常一样上传：

curl -d "{ \"operation\": \"create\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"blobName\": \"my-test-file.jpg\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "YOUR_BASE_64_CONTENT", "metadata": { "blobName": "my-test-file.jpg" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体将包含以下 JSON：

{
   "blobURL": "https://<your account name>. blob.core.windows.net/<your container name>/<filename>"
}

获取 blob

要执行获取 blob 操作，请使用 POST 方法调用 Azure Blob Storage 绑定，并使用以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "blobName": "myblob",
    "includeMetadata": "true"
  }
}

元数据参数为：

blobName - blob 的名称
includeMetadata -（可选）定义是否应返回用户定义的元数据，默认为：false

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"blobName\": \"myblob\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "blobName": "myblob" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含存储在 blob 对象中的值。如果已启用，用户定义的元数据将以以下形式的 HTTP 头返回：

Metadata.key1: value1 Metadata.key2: value2

删除 blob

要执行删除 blob 操作，请使用 POST 方法调用 Azure Blob Storage 绑定，并使用以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "blobName": "myblob"
  }
}

元数据参数为：

blobName - blob 的名称
deleteSnapshots -（可选）当 blob 有关联快照时需要。指定以下两个选项之一：
- include：删除基础 blob 及其所有快照
- only：仅删除 blob 的快照而不删除 blob 本身

示例

删除 blob

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"blobName\": \"myblob\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "blobName": "myblob" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

仅删除 blob 快照

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"blobName\": \"myblob\", \"deleteSnapshots\": \"only\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "blobName": "myblob", "deleteSnapshots": "only" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

删除 blob 及其快照

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"blobName\": \"myblob\", \"deleteSnapshots\": \"include\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "blobName": "myblob", "deleteSnapshots": "include" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

如果成功，将返回 HTTP 204（No Content）和空响应体。

列出 blob

要执行列出 blob 操作，请使用 POST 方法调用 Azure Blob Storage 绑定，并使用以下 JSON 请求体：

{
  "operation": "list",
  "data": {
    "maxResults": 10,
    "prefix": "file",
    "marker": "2!108!MDAwMDM1IWZpbGUtMDgtMDctMjAyMS0wOS0zOC01NS03NzgtMjEudHh0ITAwMDAyOCE5OTk5LTEyLTMxVDIzOjU5OjU5Ljk5OTk5OTlaIQ--",
    "include": {
      "snapshots": false,
      "metadata": true,
      "uncommittedBlobs": false,
      "copy": false,
      "deleted": false
    }
  }
}

data 参数为：

maxResults -（可选）指定最多返回的 blob 数量，包括所有 BlobPrefix 元素。如果请求未指定 maxresults，服务器将最多返回 5,000 个项目。
prefix -（可选）过滤结果，仅返回名称以指定前缀开头的 blob。
marker -（可选）一个字符串值，用于标识在下一次列表操作中要返回的列表部分。如果返回的列表不完整，操作会在响应体中返回一个 marker 值。然后可以在后续调用中使用该 marker 值来请求下一组列表项。
include -（可选）指定要在响应中包含的一个或多个数据集：
- snapshots：指定应在枚举中包含快照。快照在响应中按从最旧到最新的顺序列出。默认为：false
- metadata：指定应在响应中返回 blob 元数据。默认为：false
- uncommittedBlobs：指定响应中应包含已上传块但尚未使用 Put Block List 提交的 blob。默认为：false
- copy：版本 2012-02-12 及更新版本。指定响应中应包含与任何当前或先前 Copy Blob 操作相关的元数据。默认为：false
- deleted：版本 2017-07-29 及更新版本。指定响应中应包含已软删除的 blob。默认为：false

响应

响应体包含找到的块列表以及以下 HTTP 头：

Metadata.marker: 2!108!MDAwMDM1IWZpbGUtMDgtMDctMjAyMS0wOS0zOC0zNC04NjctMTEudHh0ITAwMDAyOCE5OTk5LTEyLTMxVDIzOjU5OjU5Ljk5OTk5OTlaIQ-- Metadata.number: 10

marker - 可在后续调用中用于请求下一组列表项的下一个 marker。请参阅绑定输入的 data 属性上的 marker 说明。
number - 找到的 blob 数量

blob 列表将以以下形式的 JSON 数组返回：

[
  {
    "XMLName": {
      "Space": "",
      "Local": "Blob"
    },
    "Name": "file-08-07-2021-09-38-13-776-1.txt",
    "Deleted": false,
    "Snapshot": "",
    "Properties": {
      "XMLName": {
        "Space": "",
        "Local": "Properties"
      },
      "CreationTime": "2021-07-08T07:38:16Z",
      "LastModified": "2021-07-08T07:38:16Z",
      "Etag": "0x8D941E3593C6573",
      "ContentLength": 1,
      "ContentType": "application/octet-stream",
      "ContentEncoding": "",
      "ContentLanguage": "",
      "ContentMD5": "xMpCOKC5I4INzFCab3WEmw==",
      "ContentDisposition": "",
      "CacheControl": "",
      "BlobSequenceNumber": null,
      "BlobType": "BlockBlob",
      "LeaseStatus": "unlocked",
      "LeaseState": "available",
      "LeaseDuration": "",
      "CopyID": null,
      "CopyStatus": "",
      "CopySource": null,
      "CopyProgress": null,
      "CopyCompletionTime": null,
      "CopyStatusDescription": null,
      "ServerEncrypted": true,
      "IncrementalCopy": null,
      "DestinationSnapshot": null,
      "DeletedTime": null,
      "RemainingRetentionDays": null,
      "AccessTier": "Hot",
      "AccessTierInferred": true,
      "ArchiveStatus": "",
      "CustomerProvidedKeySha256": null,
      "AccessTierChangeTime": null
    },
    "Metadata": null
  }
]

元数据信息

默认情况下，Azure Blob Storage 输出绑定会自动生成 UUID 作为 blob 文件名，并且不会为其分配任何系统或自定义元数据。可以在消息的元数据属性中配置（均为可选）。

向 Azure Blob Storage 输出绑定发布的应用程序应发送以下格式的消息：

{
    "data": "file content",
    "metadata": {
        "blobName"           : "filename.txt",
        "contentType"        : "text/plain",
        "contentMD5"         : "vZGKbMRDAnMs4BIwlXaRvQ==",
        "contentEncoding"    : "UTF-8",
        "contentLanguage"    : "en-us",
        "contentDisposition" : "attachment",
        "cacheControl"       : "no-cache",
        "custom"             : "hello-world"
    },
    "operation": "create"
}

11 - Azure Cosmos DB (Gremlin API) 绑定规范

Azure Cosmos DB (Gremlin API) 绑定组件的详细文档

组件格式

若要设置 Azure Cosmos DB (Gremlin API) 绑定，请创建类型为 bindings.azure.cosmosdb.gremlinapi 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.cosmosdb.gremlinapi
  version: v1
  metadata:
  - name: url
    value: "wss://******.gremlin.cosmos.azure.com:443/"
  - name: masterKey
    value: "*****"
  - name: username
    value: "*****"

警告

上述示例将密钥以纯文本字符串形式使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`url`	Y	输出	Gremlin API 的 Cosmos DB URL	`"wss://******.gremlin.cosmos.azure.com:443/"`
`masterKey`	Y	输出	Cosmos DB 账户主密钥	`"masterKey"`
`username`	Y	输出	Cosmos DB 数据库的用户名	`"/dbs/<database_name>/colls/<graph_name>"`

有关更多信息，请参阅快速入门：使用 Gremlin 的 Azure Cosmos Graph DB。

绑定支持

此组件支持输出绑定，包含以下操作：

query

请求负载示例

{
  "data": {
    "gremlin": "g.V().count()"
    },
  "operation": "query"
}

12 - Azure Cosmos DB (SQL API) 绑定规范

Azure Cosmos DB (SQL API) 绑定组件的详细文档

组件格式

若要设置 Azure Cosmos DB 绑定，需创建一个类型为 bindings.azure.cosmosdb 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.cosmosdb
  version: v1
  metadata:
  - name: url
    value: "https://******.documents.azure.com:443/"
  - name: masterKey
    value: "*****"
  - name: database
    value: "OrderDb"
  - name: collection
    value: "Orders"
  - name: partitionKey
    value: "<message>"

Warning

以上示例将密钥作为明文字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`url`	Y	输出	Cosmos DB URL	`"https://******.documents.azure.com:443/"`
`masterKey`	Y	输出	Cosmos DB 账户主密钥	`"master-key"`
`database`	Y	输出	Cosmos DB 数据库名称	`"OrderDb"`
`collection`	Y	输出	数据库中容器的名称。	`"Orders"`
`partitionKey`	Y	输出	从载荷中提取的、用作分区键的键的名称（待创建的文档）。该名称必须与创建 Cosmos DB 容器时指定的分区键一致。	`"OrderId"`、`"message"`

更多信息请参见 Azure Cosmos DB 资源模型。

Microsoft Entra ID 身份验证

Azure Cosmos DB 绑定组件支持使用所有 Microsoft Entra ID 机制进行身份验证。有关更多信息以及根据所选 Microsoft Entra ID 身份验证机制需提供的相应组件元数据字段，请参阅对 Azure 进行身份验证的文档。

你可以在以下部分中阅读有关使用 Azure AD 身份验证设置 Cosmos DB 的更多信息。

绑定支持

该组件支持输出绑定，包含以下操作：

create

生产环境最佳实践

Azure Cosmos DB 在单个 Azure Cosmos DB 账户的所有数据库之间共享严格的元数据请求速率限制。与 Azure Cosmos DB 的新连接会占用允许的请求速率限制的很大一部分。（参见 Cosmos DB 文档）

因此必须采取若干策略来避免与 Azure Cosmos DB 同时建立新连接：

确保应用程序的边车仅在需要时才加载 Azure Cosmos DB 组件，以避免不必要的数据库连接。这可以通过将组件限定于特定应用程序来实现。
选择顺序部署或启动应用程序的部署策略，以最大限度地减少到 Azure Cosmos DB 账户的新连接突增。
避免为不相关的数据库或系统复用同一个 Azure Cosmos DB 账户（即使在 Dapr 之外）。不同的 Azure Cosmos DB 账户具有不同的速率限制。
增加 initTimeout 值，允许组件在边车初始化期间重试连接到 Azure Cosmos DB，最长可达 5 分钟。默认值为 5s，应该增加。使用 Kubernetes 时，增加此值可能还需要更新就绪和存活探针。

spec:
  type: bindings.azure.cosmosdb
  version: v1
  initTimeout: 5m
  metadata:

数据格式

输出绑定的 create 操作要求每个待创建文档的载荷中存在以下键：

id：待创建文档的唯一 ID
<partitionKey>：通过组件定义中的 spec.partitionKey 指定的分区键名称。这也必须与创建 Cosmos DB 容器时指定的分区键一致。

为使用 Azure AD 身份验证设置 Cosmos DB

使用 Dapr Cosmos DB 绑定并通过 Azure AD 进行身份验证时，你需要执行一些额外步骤来设置环境。

先决条件：

你需要根据对 Azure 进行身份验证页面中的说明创建一个服务主体。下面的命令需要该服务主体的 ID（请注意，这与应用程序的客户端 ID 或你在元数据中用于 azureClientId 的值不同）。
Azure CLI
jq
以下脚本针对 bash 或 zsh shell 进行了优化

使用 Cosmos DB 绑定时，你不需要像使用 Cosmos DB 状态存储那样创建存储过程。

授予你的 Azure AD 应用程序访问 Cosmos DB 的权限

你可以在官方文档中找到更多信息，包括分配更精细权限的说明。

为了授予你的应用程序访问存储在 Cosmos DB 中的数据的权限，你需要为 Cosmos DB 数据平面分配一个自定义角色。在本例中，你将使用内置角色 “Cosmos DB Built-in Data Contributor”，该角色授予你的应用程序对数据的完全读写访问权限；你也可以按照官方文档中的说明创建自定义的、精细调整的角色。

# 包含你的 Cosmos DB 的资源组名称
RESOURCE_GROUP="..."
# 你的 Cosmos DB 账户名称
ACCOUNT_NAME="..."
# 你的服务主体对象 ID
PRINCIPAL_ID="..."
# "Cosmos DB Built-in Data Contributor" 角色的 ID
# 你也可以使用自定义角色的 ID
ROLE_ID="00000000-0000-0000-0000-000000000002"

az cosmosdb sql role assignment create \
  --account-name "$ACCOUNT_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --scope "/" \
  --principal-id "$PRINCIPAL_ID" \
  --role-definition-id "$ROLE_ID"

13 - Azure Event Grid 绑定规范

Azure Event Grid 绑定组件的详细文档

组件格式

若要设置 Azure Event Grid 绑定，请创建类型为 bindings.azure.eventgrid 的组件。请参阅此指南了解如何创建和应用绑定配置。

请参阅此处了解 Azure Event Grid 的文档。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <name>
spec:
  type: bindings.azure.eventgrid
  version: v1
  metadata:
  # 必需的输出绑定元数据
  - name: accessKey
    value: "[AccessKey]"
  - name: topicEndpoint
    value: "[TopicEndpoint]"
  # 必需的输入绑定元数据
  - name: azureTenantId
    value: "[AzureTenantId]"
  - name: azureSubscriptionId
    value: "[AzureSubscriptionId]"
  - name: azureClientId
    value: "[ClientId]"
  - name: azureClientSecret
    value: "[ClientSecret]"
  - name: subscriberEndpoint
    value: "[SubscriberEndpoint]"
  - name: handshakePort
    # 确保将此值作为字符串传递，并在值周围加上引号
    value: "[HandshakePort]"
  - name: scope
    value: "[Scope]"
  # 可选的输入绑定元数据
  - name: eventSubscriptionName
    value: "[EventSubscriptionName]"
  # 可选元数据
  - name: direction
    value: "input, output"

警告

上述示例将密钥作为纯字符串使用。建议按照此处的说明，使用密钥存储来管理密钥。

规范元数据字段

字段	必需	绑定支持	详情	示例
`accessKey`	Y	Output	用于将 Event Grid 事件发布到自定义主题的访问密钥	`"accessKey"`
`topicEndpoint`	Y	Output	此输出绑定应向其发布事件的主题端点	`"topic-endpoint"`
`azureTenantId`	Y	Input	Event Grid 资源的 Azure 租户 ID	`"tenentID"`
`azureSubscriptionId`	Y	Input	Event Grid 资源的 Azure 订阅 ID	`"subscriptionId"`
`azureClientId`	Y	Input	绑定应使用此客户端 ID 来创建或更新 Event Grid 事件订阅并对传入消息进行身份验证	`"clientId"`
`azureClientSecret`	Y	Input	绑定应使用此客户端 ID 来创建或更新 Event Grid 事件订阅并对传入消息进行身份验证	`"clientSecret"`
`subscriberEndpoint`	Y	Input	Event Grid 将事件（格式化为 Cloud Events）发送到的 webhook 的 HTTPS 端点。如果你不在入站时重写 URL，它的格式应为：`"https://[YOUR HOSTNAME]/<path>"` 如果在本地计算机上测试，可以使用 ngrok 之类的工具来创建公共端点。	`"https://[YOUR HOSTNAME]/<path>"`
`handshakePort`	Y	Input	输入绑定在 webhook 上接收事件时监听的容器端口	`"9000"`
`scope`	Y	Input	需要创建或更新事件订阅的资源的标识符。有关更多详细信息，请参阅作用域部分	`"/subscriptions/{subscriptionId}/"`
`eventSubscriptionName`	N	Input	事件订阅的名称。事件订阅名称的长度必须介于 3 到 64 个字符之间，并且应仅使用字母数字字符	`"name"`
`direction`	N	Input/Output	绑定的方向	`"input"`、`"output"`、`"input, output"`

作用域

作用域是需要创建或更新事件订阅的资源的标识符。作用域可以是订阅、资源组、属于资源提供程序命名空间的顶级资源，或 Event Grid 主题。例如：

/subscriptions/{subscriptionId}/ 表示订阅
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName} 表示资源组
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} 表示资源
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.EventGrid/topics/{topicName} 表示 Event Grid 主题

花括号 {} 中的值应替换为实际值。

绑定支持

此组件支持输入和输出绑定接口。

此组件支持输出绑定，具有以下操作：

create：在 Event Grid 主题上发布消息

接收事件

你可以使用 Event Grid 绑定从各种来源和操作接收事件。了解有关与 Event Grid 兼容的所有可用事件源和处理程序的更多信息。

在下表中，你可以找到可以引发事件的 Dapr 组件列表。

事件源	Dapr 组件
Azure Blob Storage	Azure Blob Storage 绑定 Azure Blob Storage 状态存储
Azure Cache for Redis	Redis 绑定 Redis 发布订阅
Azure Event Hubs	Azure Event Hubs 发布订阅 Azure Event Hubs 绑定
Azure IoT Hub	Azure Event Hubs 发布订阅 Azure Event Hubs 绑定
Azure Service Bus	Azure Service Bus 绑定 Azure Service Bus 发布订阅主题和队列
Azure SignalR Service	SignalR 绑定

Microsoft Entra ID 凭据

Azure Event Grid 绑定需要 Microsoft Entra ID 应用程序和服务主体，原因有两个：

在 Dapr 启动时创建事件订阅（并在 Dapr 配置更改时更新它）
对 Event Hubs 传送到你的应用程序的消息进行身份验证。

要求：

已安装 Azure CLI。
已安装 PowerShell 7。
已安装用于 PowerShell 的 Az 模块：
Install-Module Az -Scope CurrentUser -Repository PSGallery -Force
已安装用于 PowerShell 的 Microsoft.Graph 模块：
Install-Module Microsoft.Graph -Scope CurrentUser -Repository PSGallery -Force

对于第一个目的，你需要创建 Azure 服务主体。创建后，记下 Microsoft Entra ID 应用程序的 clientID（一个 UUID），并使用 Azure CLI 运行以下脚本：

# 设置你创建的应用的客户端 ID
CLIENT_ID="..."
# 资源的范围，通常格式为：
# `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.EventGrid/topics/{topicName}`
SCOPE="..."

# 首先确保已为 Event Grid 注册 Azure Resource Manager 提供程序
az provider register --namespace "Microsoft.EventGrid"
az provider show --namespace "Microsoft.EventGrid" --query "registrationState"
# 授予 SP 所需的权限，以便它可以创建 Event Grid 的事件订阅
az role assignment create --assignee "$CLIENT_ID" --role "EventGrid EventSubscription Contributor" --scopes "$SCOPE"

对于第二个目的，首先下载一个脚本：

curl -LO "https://raw.githubusercontent.com/dapr/components-contrib/master/.github/infrastructure/conformance/azure/setup-eventgrid-sp.ps1"

然后，使用 PowerShell（pwsh），运行：

# 设置你创建的应用的客户端 ID
$clientId = "..."

# 使用 Microsoft Graph 进行身份验证
# 如果需要，你可能需要在下一个命令中添加 -TenantId 标志
Connect-MgGraph -Scopes "Application.Read.All","Application.ReadWrite.All"
./setup-eventgrid-sp.ps1 $clientId

注意：如果你的目录没有为应用程序"Microsoft.EventGrid"设置服务主体，你可能需要运行命令 Connect-MgGraph 并以 Microsoft Entra ID 租户的管理员身份登录（这与 Microsoft Entra ID 目录上的权限有关，而不是 Azure 订阅）。否则，请让你的租户管理员登录并运行此 PowerShell 命令：New-MgServicePrincipal -AppId "4962773b-9cdb-44cf-a8bf-237846a00ab7"（该 UUID 是一个常量）

本地测试

安装 ngrok
使用自定义端口（例如 9000）在本地运行，用于握手

# 以端口 9000 为例
ngrok http --host-header=localhost 9000

将 ngrok 的 HTTPS 端点和自定义端口配置为输入绑定元数据
运行 Dapr

# 以 .NET core web api 和 Dapr 的默认端口为例
dapr run --app-id dotnetwebapi --app-port 5000 --dapr-http-port 3500 dotnet run

在 Kubernetes 上测试

Azure Event Grid 需要有效的 HTTPS 端点用于自定义 webhook；不接受自签名证书。为了启用从公共互联网到应用程序的 Dapr 边车的流量，你需要一个启用了 Dapr 的入口控制器。有一篇关于此主题的好文章：Kubernetes NGINX ingress controller with Dapr。

若要开始，首先为 Dapr 注释创建一个 dapr-annotations.yaml 文件：

controller:
  podAnnotations:
    dapr.io/enabled: "true"
    dapr.io/app-id: "nginx-ingress"
    dapr.io/app-port: "80"

然后使用这些注释，使用 Helm 3 将 NGINX 入口控制器安装到 Kubernetes 集群：

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install nginx-ingress ingress-nginx/ingress-nginx -f ./dapr-annotations.yaml -n default
# 获取入口控制器的公共 IP
kubectl get svc -l component=controller -o jsonpath='Public IP is: {.items[0].status.loadBalancer.ingress[0].ip}{"\n"}'

如果部署到 Azure Kubernetes Service，你可以按照Microsoft 官方文档完成剩余步骤：

向你的 DNS 区域添加 A 记录
安装 cert-manager
创建 CA 集群颁发者

启用 Event Grid 和 Dapr 之间通信的最后一步是为应用程序的服务定义 http 和自定义端口，并在 Kubernetes 中定义 ingress。此示例使用 .NET Core web api 和 Dapr 默认端口，以及自定义端口 9000 用于握手。

# dotnetwebapi.yaml
kind: Service
apiVersion: v1
metadata:
  name: dotnetwebapi
  labels:
    app: dotnetwebapi
spec:
  selector:
    app: dotnetwebapi
  ports:
    - name: webapi
      protocol: TCP
      port: 80
      targetPort: 80
    - name: dapr-eventgrid
      protocol: TCP
      port: 9000
      targetPort: 9000
  type: ClusterIP

---
  apiVersion: extensions/v1beta1
  kind: Ingress
  metadata:
    name: eventgrid-input-rule
    annotations:
      kubernetes.io/ingress.class: nginx
      cert-manager.io/cluster-issuer: letsencrypt
  spec:
    tls:
      - hosts:
        - dapr.<your custom domain>
        secretName: dapr-tls
    rules:
      - host: dapr.<your custom domain>
        http:
          paths:
            - path: /api/events
              backend:
                serviceName: dotnetwebapi
                servicePort: 9000

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: dotnetwebapi
  labels:
    app: dotnetwebapi
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dotnetwebapi
  template:
    metadata:
      labels:
        app: dotnetwebapi
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "dotnetwebapi"
        dapr.io/app-port: "5000"
    spec:
      containers:
      - name: webapi
        image: <your container image>
        ports:
        - containerPort: 5000
        imagePullPolicy: Always

将绑定和应用程序（包括入口）部署到 Kubernetes

# 部署 Dapr 组件
kubectl apply -f eventgrid.yaml
# 部署你的应用程序和 Nginx 入口
kubectl apply -f dotnetwebapi.yaml

注意： 此清单将所有内容部署到 Kubernetes 的默认命名空间。

对 Nginx 控制器的可能问题进行故障排除

初始部署后，“Daprized” Nginx 控制器可能会发生故障。要检查日志并修复问题（如果存在），请按照以下步骤操作。

$ kubectl get pods -l app=nginx-ingress

NAME                                                   READY   STATUS    RESTARTS   AGE
nginx-nginx-ingress-controller-649df94867-fp6mg        2/2     Running   0          51m
nginx-nginx-ingress-default-backend-6d96c457f6-4nbj5   1/1     Running   0          55m

$ kubectl logs nginx-nginx-ingress-controller-649df94867-fp6mg nginx-ingress-controller

# 如果你在日志中看到从对 webhook 端点 '/api/events' 的调用返回 503，则重启 Pod
# .."OPTIONS /api/events HTTP/1.1" 503..

$ kubectl delete pod nginx-nginx-ingress-controller-649df94867-fp6mg

# 再次检查日志 - 它应该开始返回 200
# .."OPTIONS /api/events HTTP/1.1" 200..

14 - Azure Event Hubs 绑定规约

Azure Event Hubs 绑定组件的详细文档

组件格式

要设置 Azure Event Hubs 绑定，请创建一个类型为 bindings.azure.eventhubs 的组件。请参阅此指南了解如何创建和应用绑定配置。

请参阅此文档了解如何设置 Event Hub。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.eventhubs
  version: v1
  metadata:
    # Hub 名称（"topic"）
    - name: eventHub
      value: "mytopic"
    - name: consumerGroup
      value: "myapp"
    # connectionString 或 eventHubNamespace 其中之一是必需的
    # 当*不*使用 Microsoft Entra ID 时使用 connectionString
    - name: connectionString
      value: "Endpoint=sb://{EventHubNamespace}.servicebus.windows.net/;SharedAccessKeyName={PolicyName};SharedAccessKey={Key};EntityPath={EventHub}"
    # 使用 Microsoft Entra ID 时使用 eventHubNamespace
    - name: eventHubNamespace
      value: "namespace"
    - name: enableEntityManagement
      value: "false"
    - name: enableInOrderMessageDelivery
      value: "false"
    # 仅当 enableEntityManagement 设置为 true 时才需要以下四个属性
    - name: resourceGroupName
      value: "test-rg"
    - name: subscriptionID
      value: "value of Azure subscription ID"
    - name: partitionCount
      value: "1"
    - name: messageRetentionInDays
      value: "3"
    # 检查点存储属性
    - name: storageAccountName
      value: "myeventhubstorage"
    - name: storageAccountKey
      value: "112233445566778899"
    - name: storageContainerName
      value: "myeventhubstoragecontainer"
    # 传递 storageAccountKey 的替代方案
    - name: storageConnectionString
      value: "DefaultEndpointsProtocol=https;AccountName=<account>;AccountKey=<account-key>"
    # 可选元数据
    - name: getAllMessageProperties
      value: "true"
    - name: direction
      value: "input, output"

警告

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规格元数据字段

字段	必填	绑定支持	详情	示例
`eventHub`	Y*	输入/输出	Event Hubs hub 的名称（“topic”）。当使用 Microsoft Entra ID 身份验证或连接字符串不包含 `EntityPath` 值时必需	`mytopic`
`connectionString`	Y*	输入/输出	Event Hub 或 Event Hub 命名空间的连接字符串。 * 与 `eventHubNamespace` 字段互斥。 * 当不使用 Microsoft Entra ID 身份验证时必需	`"Endpoint=sb://{EventHubNamespace}.servicebus.windows.net/;SharedAccessKeyName={PolicyName};SharedAccessKey={Key};EntityPath={EventHub}"` 或 `"Endpoint=sb://{EventHubNamespace}.servicebus.windows.net/;SharedAccessKeyName={PolicyName};SharedAccessKey={Key}"`
`eventHubNamespace`	Y*	输入/输出	Event Hub 命名空间名称。 * 与 `connectionString` 字段互斥。 * 当使用 Microsoft Entra ID 身份验证时必需	`"namespace"`
`enableEntityManagement`	N	输入/输出	允许管理 EventHub 命名空间和存储帐户的布尔值。默认值：`false`	`"true"`, `"false"`
`enableInOrderMessageDelivery`	N	输入/输出	允许按发布顺序传递消息的布尔值。这假设在发布或发布时设置了 `partitionKey` 以确保跨分区的顺序。默认值：`false`	`"true"`, `"false"`
`resourceGroupName`	N	输入/输出	Event Hub 命名空间所属的资源组名称。当启用实体管理时必需	`"test-rg"`
`subscriptionID`	N	输入/输出	Azure 订阅 ID 值。当启用实体管理时必需	`"azure subscription id"`
`partitionCount`	N	输入/输出	新 Event Hub 命名空间的分区数。仅在启用实体管理时使用。默认值：`"1"`	`"2"`
`messageRetentionInDays`	N	输入/输出	在新创建的 Event Hub 命名空间中保留消息的天数。仅在启用实体管理时使用。默认值：`"1"`	`"90"`
`consumerGroup`	Y	输入	要侦听的 Event Hubs 消费者组的名称	`"group1"`
`storageAccountName`	Y	输入	用于检查点存储的存储帐户名称。	`"myeventhubstorage"`
`storageAccountKey`	Y*	输入	检查点存储帐户的存储帐户密钥。 * 使用 Microsoft Entra ID 时，如果服务主体也有权访问存储帐户，则可以省略此字段。	`"112233445566778899"`
`storageConnectionString`	Y*	输入	检查点存储的连接字符串，是指定 `storageAccountKey` 的替代方案	`"DefaultEndpointsProtocol=https;AccountName=myeventhubstorage;AccountKey=<account-key>"`
`storageContainerName`	Y	输入	存储帐户名称的存储容器名称。	`"myeventhubstoragecontainer"`
`getAllMessageProperties`	N	输入	当设置为 `true` 时，从 Event Hub 消息中检索所有用户/应用程序/自定义属性，并在返回的事件元数据中转发它们。默认设置为 `"false"`。	`"true"`, `"false"`
`direction`	N	输入/输出	绑定的方向。	`"input"`, `"output"`, `"input, output"`

Microsoft Entra ID 身份验证

Azure Event Hubs 发布/订阅组件支持使用所有 Microsoft Entra ID 机制进行身份验证。有关更多信息以及根据选择的 Microsoft Entra ID 身份验证机制需要提供的相关组件元数据字段，请参阅向 Azure 进行身份验证的文档。

绑定支持

此组件支持输出绑定，具有以下操作：

create：向 Azure Event Hubs 发布新消息

输入绑定到 Azure IoT Hub 事件

Azure IoT Hub 提供一个与 Event Hubs 兼容的端点，因此 Dapr 应用程序可以创建输入绑定，使用 Event Hubs 绑定组件来读取 Azure IoT Hub 事件。

由 Azure IoT Hub 设备创建的设备到云事件将包含其他IoT Hub 系统属性，Dapr 的 Azure Event Hubs 绑定将在响应元数据中返回以下内容：

系统属性名称	描述与路由查询关键字
`iothub-connection-auth-generation-id`	发送消息的设备的 connectionDeviceGenerationId。请参阅 IoT Hub 设备标识属性。
`iothub-connection-auth-method`	用于对发送消息的设备进行身份验证的 connectionAuthMethod。
`iothub-connection-device-id`	发送消息的设备的 deviceId。请参阅 IoT Hub 设备标识属性。
`iothub-connection-module-id`	发送消息的设备的 moduleId。请参阅 IoT Hub 设备标识属性。
`iothub-enqueuedtime`	设备到云消息被 IoT Hub 接收的 enqueuedTime，采用 RFC3339 格式。
`message-id`	用户可设置的 AMQP messageId。

例如，HTTP Read() 响应的标头将包含：

{
  'user-agent': 'fasthttp',
  'host': '127.0.0.1:3000',
  'content-type': 'application/json',
  'content-length': '120',
  'iothub-connection-device-id': 'my-test-device',
  'iothub-connection-auth-generation-id': '637618061680407492',
  'iothub-connection-auth-method': '{"scope":"module","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}',
  'iothub-connection-module-id': 'my-test-module-a',
  'iothub-enqueuedtime': '2021-07-13T22:08:09Z',
  'message-id': 'my-custom-message-id',
  'x-opt-sequence-number': '35',
  'x-opt-enqueued-time': '2021-07-13T22:08:09Z',
  'x-opt-offset': '21560',
  'traceparent': '00-4655608164bc48b985b42d39865f3834-ed6cf3697c86e7bd-01'
}

15 - Azure OpenAI binding 规范

Azure OpenAI binding 组件的详细文档

组件格式

若要设置 Azure OpenAI binding，请创建类型为 bindings.azure.openai 的组件。请参阅本指南了解如何创建和应用 binding 配置。请参阅此处获取 Azure OpenAI 服务的文档。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.openai
  version: v1
  metadata:
  - name: apiKey # 必填
    value: "1234567890abcdef"
  - name: endpoint # 必填
    value: "https://myopenai.openai.azure.com"

警告

上述示例将 apiKey 作为纯字符串使用。建议按照此处所述使用 secret store 来管理密钥。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`endpoint`	Y	Output	Azure OpenAI 服务端点 URL。	`"https://myopenai.openai.azure.com"`
`apiKey`	Y*	Output	Azure OpenAI 服务的访问密钥。仅在不使用 Microsoft Entra ID 身份验证时需要。	`"1234567890abcdef"`
`azureTenantId`	Y*	Input	Azure OpenAI 资源的租户 ID。仅当未提供 `apiKey` 时需要。	`"tenentID"`
`azureClientId`	Y*	Input	Binding 应使用的客户端 ID，用于创建或更新 Azure OpenAI 订阅并对传入消息进行身份验证。仅当未提供 `apiKey` 时需要。	`"clientId"`
`azureClientSecret`	Y*	Input	Binding 应使用的客户端密钥，用于创建或更新 Azure OpenAI 订阅并对传入消息进行身份验证。仅当未提供 `apiKey` 时需要。	`"clientSecret"`

Microsoft Entra ID 身份验证

Azure OpenAI binding 组件支持使用所有 Microsoft Entra ID 机制进行身份验证。有关更多信息以及根据选择的 Microsoft Entra ID 身份验证机制需要提供的组件元数据字段，请参阅向 Azure 进行身份验证的文档。

配置示例

apiVersion: dapr.io/v1alpha1
kind: component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.openai
  version: v1
  metadata:
  - name: endpoint
    value: "https://myopenai.openai.azure.com"
  - name: azureTenantId
    value: "***"
  - name: azureClientId
    value: "***"
  - name: azureClientSecret
    value: "***"

Binding 支持

此组件支持以下操作的输出 binding：

completion：补全 API
chat-completion：聊天补全 API
get-embedding：嵌入 API

Completion API

要使用提示调用补全 API，请使用 POST 方法调用 Azure OpenAI binding，并使用以下 JSON 请求体：

{
  "operation": "completion",
  "data": {
    "deploymentId": "my-model",
    "prompt": "A dog is",
    "maxTokens":5
    }
}

数据参数包括：

deploymentId - 指定要使用的模型部署 ID 的字符串。
prompt - 指定要生成补全的提示的字符串。
maxTokens - （可选）定义要生成的 token 最大数量。补全 API 默认为 16。
temperature - （可选）定义 0 到 2 之间的采样温度。较高的值（如 0.8）会使输出更加随机，而较低的值（如 0.2）则使其更加聚焦和确定性。补全 API 默认为 1.0。
topP - （可选）定义采样温度。补全 API 默认为 1.0。
n - （可选）定义要生成的补全数量。补全 API 默认为 1。
presencePenalty - （可选）介于 -2.0 和 2.0 之间的数字。正值会根据新 token 是否出现在已有文本中来对其进行惩罚，从而增加模型谈论新主题的可能性。补全 API 默认为 0.0。
frequencyPenalty - （可选）介于 -2.0 和 2.0 之间的数字。正值会根据新 token 在已有文本中的现有频率对其进行惩罚，从而降低模型逐字重复同一行的可能性。补全 API 默认为 0.0。

在 Azure OpenAI API 文档中阅读有关这些参数的重要性和用法的更多信息。

示例

curl -d '{ "data": {"deploymentId: "my-model" , "prompt": "A dog is ", "maxTokens":15}, "operation": "completion" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下 JSON：

[
  {
    "finish_reason": "length",
    "index": 0,
    "text": " a pig in a dress.\n\nSun, Oct 20, 2013"
  },
  {
    "finish_reason": "length",
    "index": 1,
    "text": " the only thing on earth that loves you\n\nmore than he loves himself.\"\n\n"
  }
]

Chat Completion API

要执行聊天补全操作，请使用 POST 方法调用 Azure OpenAI binding，并使用以下 JSON 请求体：

{
    "operation": "chat-completion",
    "data": {
        "deploymentId": "my-model",
        "messages": [
            {
                "role": "system",
                "message": "You are a bot that gives really short replies"
            },
            {
                "role": "user",
                "message": "Tell me a joke"
            }
        ],
        "n": 2,
        "maxTokens": 30,
        "temperature": 1.2
    }
}

数据参数包括：

deploymentId - 指定要使用的模型部署 ID 的字符串。
messages - 将用于生成聊天补全的消息数组。每条消息的格式为：
- role - 指定消息角色的字符串。可以是 user、system 或 assistant。
- message - 指定该角色的对话消息的字符串。
maxTokens - （可选）定义要生成的 token 最大数量。聊天补全 API 默认为 16。
temperature - （可选）定义 0 到 2 之间的采样温度。较高的值（如 0.8）会使输出更加随机，而较低的值（如 0.2）则使其更加聚焦和确定性。聊天补全 API 默认为 1.0。
topP - （可选）定义采样温度。聊天补全 API 默认为 1.0。
n - （可选）定义要生成的补全数量。聊天补全 API 默认为 1。
presencePenalty - （可选）介于 -2.0 和 2.0 之间的数字。正值会根据新 token 是否出现在已有文本中来对其进行惩罚，从而增加模型谈论新主题的可能性。聊天补全 API 默认为 0.0。
frequencyPenalty - （可选）介于 -2.0 和 2.0 之间的数字。正值会根据新 token 在已有文本中的现有频率对其进行惩罚，从而降低模型逐字重复同一行的可能性。聊天补全 API 默认为 0.0。

示例

curl -d '{
  "data": {
      "deploymentId": "my-model",
      "messages": [
          {
              "role": "system",
              "message": "You are a bot that gives really short replies"
          },
          {
              "role": "user",
              "message": "Tell me a joke"
          }
      ],
      "n": 2,
      "maxTokens": 30,
      "temperature": 1.2
  },
  "operation": "chat-completion"
}' \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下 JSON：

[
  {
    "finish_reason": "stop",
    "index": 0,
    "message": {
      "content": "Why was the math book sad? Because it had too many problems.",
      "role": "assistant"
    }
  },
  {
    "finish_reason": "stop",
    "index": 1,
    "message": {
      "content": "Why did the tomato turn red? Because it saw the salad dressing!",
      "role": "assistant"
    }
  }
]

Get Embedding API

get-embedding 操作返回给定输入的向量表示，可以轻松被机器学习模型和其他算法使用。要执行 get-embedding 操作，请使用 POST 方法调用 Azure OpenAI binding，并使用以下 JSON 请求体：

{
    "operation": "get-embedding",
    "data": {
        "deploymentId": "my-model",
        "message": "The capital of France is Paris."
    }
}

数据参数包括：

deploymentId - 指定要使用的模型部署 ID 的字符串。
message - 指定要嵌入的文本的字符串。

示例

curl -d '{
  "data": {
      "deploymentId": "embeddings",
      "message": "The capital of France is Paris."
  },
  "operation": "get-embedding"
}' \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下 JSON：

[0.018574921,-0.00023652936,-0.0057790717,.... (ada 总共 1536 个浮点数)]

了解有关 Azure OpenAI 输出 binding 的更多信息

观看以下社区呼叫演示以了解有关 Azure OpenAI 输出 binding 的更多信息。

16 - Azure Service Bus Queues 绑定规范

Azure Service Bus Queues 绑定组件的详细文档

组件格式

要设置 Azure Service Bus Queues 绑定，请创建类型为 bindings.azure.servicebusqueues 的组件。有关如何创建和应用绑定配置，请参阅此指南。

连接字符串身份验证

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.servicebusqueues
  version: v1
  metadata:
  - name: connectionString # 当不使用 Azure 身份验证时必需。
    value: "Endpoint=sb://{ServiceBusNamespace}.servicebus.windows.net/;SharedAccessKeyName={PolicyName};SharedAccessKey={Key};EntityPath={ServiceBus}"
  - name: queueName
    value: "queue1"
  # - name: timeoutInSec # 可选
  #   value: "60"
  # - name: handlerTimeoutInSec # 可选
  #   value: "60"
  # - name: disableEntityManagement # 可选
  #   value: "false"
  # - name: maxDeliveryCount # 可选
  #   value: "3"
  # - name: lockDurationInSec # 可选
  #   value: "60"
  # - name: lockRenewalInSec # 可选
  #   value: "20"
  # - name: maxActiveMessages # 可选
  #   value: "10000"
  # - name: maxConcurrentHandlers # 可选
  #   value: "10"
  # - name: defaultMessageTimeToLiveInSec # 可选
  #   value: "10"
  # - name: autoDeleteOnIdleInSec # 可选
  #   value: "3600"
  # - name: minConnectionRecoveryInSec # 可选
  #   value: "2"
  # - name: maxConnectionRecoveryInSec # 可选
  #   value: "300"
  # - name: maxRetriableErrorsPerSec # 可选
  #   value: "10"
  # - name: publishMaxRetries # 可选
  #   value: "5"
  # - name: publishInitialRetryIntervalInMs # 可选
  #   value: "500"
  # - name: direction
  #   value: "input, output"

警告

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详细说明	示例
`connectionString`	Y	输入/输出	Service Bus 连接字符串。除非使用 Microsoft Entra ID 身份验证，否则为必需。	`"Endpoint=sb://************"`
`queueName`	Y	输入/输出	Service Bus 队列名称。队列名称不区分大小写，并将始终被强制转换为小写。	`"queuename"`
`timeoutInSec`	N	输入/输出	对 Azure Service Bus 端点的所有调用的超时时间（秒）。请注意，此选项影响网络调用，与应用于消息的 TTL 无关。默认值：`"60"`	`"60"`
`namespaceName`	N	输入/输出	用于设置 Service Bus 命名空间地址的参数，格式为完全限定域名。如果使用 Microsoft Entra ID 身份验证，则为必需。	`"namespace.servicebus.windows.net"`
`disableEntityManagement`	N	输入/输出	当设置为 true 时，队列和订阅不会自动创建。默认值：`"false"`	`"true"`, `"false"`
`lockDurationInSec`	N	输入/输出	定义消息在过期前被锁定的时间长度（秒）。仅在订阅创建期间使用。默认值由服务器设置。	`"30"`
`autoDeleteOnIdleInSec`	N	输入/输出	在自动删除空闲订阅之前等待的时间（秒）。仅在订阅创建期间使用。必须大于或等于 300 秒。默认值：`"0"`（禁用）	`"3600"`
`defaultMessageTimeToLiveInSec`	N	输入/输出	默认消息生存时间（秒）。仅在订阅创建期间使用。	`"10"`
`maxDeliveryCount`	N	输入/输出	定义服务器尝试传递消息的次数。仅在订阅创建期间使用。默认值由服务器设置。	`"10"`
`minConnectionRecoveryInSec`	N	输入/输出	在连接失败时尝试重新连接到 Azure Service Bus 之前等待的最小时间间隔（秒）。默认值：`"2"`	`"5"`
`maxConnectionRecoveryInSec`	N	输入/输出	在连接失败时尝试重新连接到 Azure Service Bus 之前等待的最大时间间隔（秒）。每次尝试后，组件会在最小值和最大值之间等待一个随机秒数，且每次递增。默认值：`"300"`（5 分钟）	`"600"`
`maxActiveMessages`	N	定义一次要处理或在缓冲区中的最大消息数。此值应至少与最大并发处理程序数一样大。默认值：`"1"`	`"1"`
`handlerTimeoutInSec`	N	输入	调用应用程序处理程序的超时时间。默认值：`"0"`（无超时）	`"30"`
`minConnectionRecoveryInSec`	N	输入	在连接失败时尝试重新连接到 Azure Service Bus 之前等待的最小时间间隔（秒）。默认值：`"2"`	`"5"`
`maxConnectionRecoveryInSec`	N	输入	在连接失败时尝试重新连接到 Azure Service Bus 之前等待的最大时间间隔（秒）。每次尝试后，绑定会在最小值和最大值之间等待一个随机秒数，且每次递增。默认值：`"300"`（5 分钟）	`"600"`
`lockRenewalInSec`	N	输入	定义缓冲消息锁的续订频率。默认值：`"20"`。	`"20"`
`maxActiveMessages`	N	输入	定义一次要处理或在缓冲区中的最大消息数。此值应至少与最大并发处理程序数一样大。默认值：`"1"`	`"2000"`
`maxConcurrentHandlers`	N	输入	定义最大并发消息处理程序数；设置为 `0` 表示无限制。默认值：`"1"`	`"10"`
`maxRetriableErrorsPerSec`	N	输入	每秒处理的最大可重试错误数。如果消息处理失败并出现可重试错误，组件会在开始处理另一条消息之前添加延迟，以避免立即重新处理失败的消息。默认值：`"10"`	`"10"`
`publishMaxRetries`	N	输出	当 Azure Service Bus 响应"太忙"以限制消息时的最大重试次数。默认值：`"5"`	`"5"`
`publishInitialRetryIntervalInMs`	N	输出	当 Azure Service Bus 限制消息时的初始指数退避时间（毫秒）。默认值：`"500"`	`"500"`
`direction`	N	输入/输出	绑定的方向	`"input"`, `"output"`, `"input, output"`

Microsoft Entra ID 身份验证

Azure Service Bus Queues 绑定组件支持使用所有 Microsoft Entra ID 机制进行身份验证，包括托管标识。有关更多信息以及根据 Microsoft Entra ID 身份验证机制的选择提供的相应组件元数据字段，请参阅Azure 身份验证文档。

配置示例

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.servicebusqueues
  version: v1
  metadata:
  - name: azureTenantId
    value: "***"
  - name: azureClientId
    value: "***"
  - name: azureClientSecret
    value: "***"
  - name: namespaceName
    # 使用 Azure 身份验证时必需。
    # 必须是完全限定域名
    value: "servicebusnamespace.servicebus.windows.net"
  - name: queueName
    value: queue1
  - name: ttlInSeconds
    value: 60

绑定支持

此组件同时支持输入和输出绑定接口。

此组件支持输出绑定，具有以下操作：

create：将消息发布到指定的队列

消息元数据

Azure Service Bus 消息使用其他上下文元数据扩展了 Dapr 消息格式。某些元数据字段由 Azure Service Bus 本身设置（只读），其他字段可以在通过 Invoke 绑定调用发布消息时由客户端设置。

发送带有元数据的消息

要在发送消息时设置 Azure Service Bus 元数据，请在 HTTP 请求或 gRPC 元数据上设置查询参数，如此处所述。

metadata.MessageId
metadata.CorrelationId
metadata.SessionId
metadata.Label
metadata.ReplyTo
metadata.PartitionKey
metadata.To
metadata.ContentType
metadata.ScheduledEnqueueTimeUtc
metadata.ReplyToSessionId

注意

metadata.MessageId 属性不会设置 Dapr 返回的 cloud event 的 id 属性，应单独处理。
metadata.ScheduledEnqueueTimeUtc 属性支持 RFC1123 和 RFC3339 时间戳格式。

接收带有元数据的消息

当 Dapr 调用您的应用程序时，它会使用 HTTP 标头或 gRPC 元数据将 Azure Service Bus 消息元数据附加到请求中。除了上面列出的可设置元数据之外，您还可以访问以下只读消息元数据。

metadata.DeliveryCount
metadata.LockedUntilUtc
metadata.LockToken
metadata.EnqueuedTimeUtc
metadata.SequenceNumber

要了解有关这些元数据属性用途的更多详细信息，请参阅官方 Azure Service Bus 文档。

此外，原始 Azure Service Bus 消息的所有 ApplicationProperties 条目都会作为 metadata.<application property's name> 附加。

注意

所有时间都由服务器填充，不会针对时钟偏差进行调整。

为每条消息指定 TTL

生存时间可以在每个队列级别定义（如上所示）或在消息级别定义。在消息级别定义的值会覆盖在队列级别设置的任何值。

要在消息级别设置生存时间，请在绑定调用期间使用请求正文中的 metadata 部分：字段名称为 ttlInSeconds。

curl -X POST http://localhost:3500/v1.0/bindings/myServiceBusQueue \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "ttlInSeconds": "60"
        },
        "operation": "create"
      }'

计划消息

消息可以计划延迟处理。

要计划消息，请在绑定调用期间使用请求正文中的 metadata 部分：字段名称为 ScheduledEnqueueTimeUtc。

支持的时间戳格式为 RFC1123 和 RFC3339。

curl -X POST http://localhost:3500/v1.0/bindings/myServiceBusQueue \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "ScheduledEnqueueTimeUtc": "Tue, 02 Jan 2024 15:04:05 GMT"
        },
        "operation": "create"
      }'

17 - Azure SignalR 绑定规范

Azure SignalR 绑定组件的详细文档

组件格式

若要设置 Azure SignalR 绑定，需创建一个类型为 bindings.azure.signalr 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.signalr
  version: v1
  metadata:
  - name: connectionString
    value: "Endpoint=https://<your-azure-signalr>.service.signalr.net;AccessKey=<your-access-key>;Version=1.0;"
  - name: hub  # Optional
    value: "<hub name>"

Warning

上述示例将密钥以纯字符串形式使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`connectionString`	Y	Output	Azure SignalR 连接字符串	`"Endpoint=https://<your-azure-signalr>.service.signalr.net;AccessKey=<your-access-key>;Version=1.0;"`
`hub`	N	Output	定义消息发送到的 Hub。Hub 可以在发布到输出绑定时作为元数据值（键为 “hub”）动态定义	`"myhub"`
`endpoint`	N	Output	Azure SignalR 的终结点；如果 `connectionString` 中未包含或使用 Microsoft Entra ID 时必需	`"https://<your-azure-signalr>.service.signalr.net"`
`accessKey`	N	Output	访问密钥	`"your-access-key"`

Microsoft Entra ID 身份验证

Azure SignalR 绑定组件支持使用所有 Microsoft Entra ID 机制进行身份验证。请参阅向 Azure 进行身份验证的文档，根据您选择的 Microsoft Entra ID 身份验证机制了解相关组件元数据字段。

您可以通过两种选项使用 Microsoft Entra ID 对此组件进行身份验证：

传递单独的元数据键：
- endpoint 用于终结点
- 如需要：azureClientId、azureTenantId 和 azureClientSecret
传递指定了 AuthType=aad 的连接字符串：
- 系统分配的托管标识：Endpoint=https://<servicename>.service.signalr.net;AuthType=aad;Version=1.0;
- 用户分配的托管标识：Endpoint=https://<servicename>.service.signalr.net;AuthType=aad;ClientId=<clientid>;Version=1.0;
- Microsoft Entra ID 应用程序：Endpoint=https://<servicename>.service.signalr.net;AuthType=aad;ClientId=<clientid>;ClientSecret=<clientsecret>;TenantId=<tenantid>;Version=1.0;
  注意，如果您的应用程序的 ClientSecret 包含 ; 字符，则不能使用连接字符串。

绑定支持

此组件支持 输出绑定，具有以下操作：

create

其他信息

默认情况下，Azure SignalR 输出绑定将向所有已连接的用户广播消息。若要缩小受众范围，有两个选项，均可在消息的 Metadata 属性中进行配置：

group：将消息发送到特定的 Azure SignalR 组
user：将消息发送到特定的 Azure SignalR 用户

向 Azure SignalR 输出绑定发布的应用程序应发送具有以下合约的消息：

{
    "data": {
        "Target": "<enter message name>",
        "Arguments": [
            {
                "sender": "dapr",
                "text": "Message from dapr output binding"
            }
        ]
    },
    "metadata": {
        "group": "chat123"
    },
    "operation": "create"
}

有关将 Azure SignalR 集成到解决方案中的更多信息，请查看文档

18 - Azure Storage Queues binding spec

Detailed documentation on the Azure Storage Queues binding component

组件格式

若要设置 Azure Storage Queues 绑定，请创建类型为 bindings.azure.storagequeues 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.azure.storagequeues
  version: v1
  metadata:
  - name: accountName
    value: "account1"
  - name: accountKey
    value: "***********"
  - name: queueName
    value: "myqueue"
# - name: pollingInterval
#   value: "30s"
# - name: ttlInSeconds
#   value: "60"
# - name: decodeBase64
#   value: "false"
# - name: encodeBase64
#   value: "false"
# - name: endpoint
#   value: "http://127.0.0.1:10001"
# - name: visibilityTimeout
#   value: "30s"
# - name: initialVisibilityDelay
#   value: "30s"
# - name: direction 
#   value: "input, output"

Warning

上述示例将密钥以纯文本字符串形式使用。建议按照此处所述，使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详细信息	示例
`accountName`	Y	Input/Output	Azure 存储账户的名称	`"account1"`
`accountKey`	Y*	Input/Output	Azure 存储账户的访问密钥。仅在不使用 Microsoft Entra ID 身份验证时需要。	`"access-key"`
`queueName`	Y	Input/Output	Azure 存储队列的名称	`"myqueue"`
`pollingInterval`	N	Output	设置轮询 Azure Storage Queues 以获取新消息的间隔，以 Go duration 值表示。默认：`"10s"`	`"30s"`
`ttlInSeconds`	N	Output	用于设置默认消息生存时间的参数。如果省略此参数，消息将在 10 分钟后过期。另请参阅此处	`"60"`
`decodeBase64`	N	Input	配置是否将从存储队列接收的 base64 内容解码为字符串。默认为 `false`	`true`, `false`
`encodeBase64`	N	Output	如果启用，在上传到 Azure 存储队列之前将数据负载进行 base64 编码。默认 `false`。	`true`, `false`
`endpoint`	N	Input/Output	可选的自定义端点 URL。这在使用 Azurite 模拟器或为 Azure 存储使用自定义域时很有用（尽管后者不受官方支持）。端点必须是完整的基础 URL，包括协议（`http://` 或 `https://`）、IP 或 FQDN 以及可选端口。	`"http://127.0.0.1:10001"` 或 `"https://accountName.queue.example.com"`
`initialVisibilityDelay`	N	Input	允许设置自定义队列可见性超时，以避免立即重试最近失败的消息。默认为 30 秒。	`"100s"`
`visibilityTimeout`	N	Input	设置消息在添加到队列后变为可见之前的延迟。还可以通过在调用请求的元数据中设置 `initialVisibilityDelay` 属性来为每条消息指定此延迟。默认为 0 秒。	`"30s"`
`direction`	N	Input/Output	绑定的方向。	`"input"`, `"output"`, `"input, output"`

Microsoft Entra ID 身份验证

Azure Storage Queue 绑定组件支持使用所有 Microsoft Entra ID 机制进行身份验证。请参阅向 Azure 进行身份验证的文档，根据您选择的 Microsoft Entra ID 身份验证机制，了解相关的组件元数据字段。

绑定支持

此组件同时支持 输入和输出 绑定接口。

此组件支持具有以下操作的 输出绑定：

create

为每条消息指定 TTL

生存时间可以在队列级别定义（如上所示）或在消息级别定义。在消息级别定义的值会覆盖在队列级别设置的任何值。

要在消息级别设置生存时间，请在绑定调用期间使用请求正文中的 metadata 部分。

字段名称为 ttlInSeconds。

示例：

curl -X POST http://localhost:3500/v1.0/bindings/myStorageQueue \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "ttlInSeconds": "60"
        },
        "operation": "create"
      }'

为每条消息指定初始可见性延迟

初始可见性延迟可以在队列级别或消息级别定义。在消息级别定义的值会覆盖在队列级别设置的任何值。

要在消息级别设置初始可见性延迟值，请在绑定调用期间使用请求正文中的 metadata 部分。

字段名称为 initialVisbilityDelay。

示例：

curl -X POST http://localhost:3500/v1.0/bindings/myStorageQueue \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "initialVisbilityDelay": "30"
        },
        "operation": "create"
      }'

19 - Cloudflare Queues 绑定规范

Cloudflare Queues 组件的详细文档

组件格式

用于 Dapr 的此输出绑定允许与 Cloudflare Queues 交互以发布新消息。目前无法使用 Dapr 从队列消费消息。

要设置 Cloudflare Queues 绑定，请创建类型为 bindings.cloudflare.queues 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.cloudflare.queues
  version: v1
  # 如果 Dapr 正在为您管理 Worker，请增加 initTimeout
  initTimeout: "120s"
  metadata:
    # 现有 Cloudflare Queue 的名称（必需）
    - name: queueName
      value: ""
    # Worker 的名称（必需）
    - name: workerName
      value: ""
    # PEM 编码的 Ed25519 私钥（必需）
    - name: key
      value: |
        -----BEGIN PRIVATE KEY-----
        MC4CAQ...
        -----END PRIVATE KEY-----
    # Cloudflare 账户 ID（让 Dapr 管理 Worker 所需）
    - name: cfAccountID
      value: ""
    # Cloudflare 的 API 令牌（让 Dapr 管理 Worker 所需）
    - name: cfAPIToken
      value: ""
    # Worker 的 URL（如果在 Dapr 之外预创建 Worker 则必需）
    - name: workerUrl
      value: ""

警告

上面的示例将密钥作为纯字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详细信息	示例
`queueName`	Y	输出	现有 Cloudflare Queue 的名称	`"mydaprqueue"`
`key`	Y	输出	Ed25519 私钥，PEM 编码	见上方示例
`cfAccountID`	Y/N	输出	Cloudflare 账户 ID。让 Dapr 管理 Worker 时必需。	`"456789abcdef8b5588f3d134f74ac"def`
`cfAPIToken`	Y/N	输出	Cloudflare 的 API 令牌。让 Dapr 管理 Worker 时必需。	`"secret-key"`
`workerUrl`	Y/N	输出	Worker 的 URL。如果在 Dapr 之外预配置 Worker 则必需。	`"https://mydaprqueue.mydomain.workers.dev`

当您配置 Dapr 为您创建 Worker 时，您可能需要为组件的 initTimeout 属性设置更长的值，以便为部署 Worker 脚本预留足够的时间。例如：initTimeout: "120s"

绑定支持

此组件支持具有以下操作的输出绑定：

publish（别名：create）：向队列发布消息。
传递给绑定的数据将按原样用作发布到队列的消息正文。
此操作不接受任何元数据属性。

创建 Cloudflare Queue

要使用此组件，您必须在 Cloudflare 账户中创建一个 Cloudflare Queue。

您可以通过以下两种方式之一创建新队列：

使用 Cloudflare 控制面板

使用 Wrangler CLI：

# 如需身份验证，请先执行 `npx wrangler login`
npx wrangler queues create <NAME>
# 例如：`npx wrangler queues create myqueue`

配置 Worker

由于 Cloudflare Queues 只能由在 Workers 上运行的脚本访问，Dapr 需要维护一个 Worker 来与队列通信。

Dapr 可以自动为您管理 Worker，或者您可以自己预先配置 Worker。在 workerd 上运行时，预先配置 Worker 是唯一支持的选项。

重要

为每个 Dapr 组件使用单独的 Worker。不要为不同的 Cloudflare Queues 绑定使用相同的 Worker 脚本，也不要为 Dapr 中不同的 Cloudflare 组件（例如，Workers KV 状态存储和 Queues 绑定）使用相同的 Worker 脚本。

如果您想让 Dapr 为您管理 Worker，您需要提供这 3 个元数据选项：

workerName：Worker 脚本的名称。这将是您的 Worker URL 的第一部分。例如，如果为您的 Cloudflare 账户配置的 “workers.dev” 域是 mydomain.workers.dev 并且您将 workerName 设置为 mydaprqueue，Dapr 部署的 Worker 将在 https://mydaprqueue.mydomain.workers.dev 上可用。
cfAccountID：您的 Cloudflare 账户的 ID。登录到 Cloudflare 控制面板后，您可以在浏览器的 URL 栏中找到它，ID 紧跟在 dash.cloudflare.com 之后。例如，如果 URL 是 https://dash.cloudflare.com/456789abcdef8b5588f3d134f74acdef，则 cfAccountID 的值是 456789abcdef8b5588f3d134f74acdef。
cfAPIToken：具有创建和编辑 Workers 权限的 API 令牌。您可以在 Cloudflare 控制面板的 “My Profile” 部分的 “API Tokens” 页面中创建它：
1. 点击 “Create token”。
2. 选择 “Edit Cloudflare Workers” 模板。
3. 按照屏幕上的说明生成新的 API 令牌。

当 Dapr 配置为为您管理 Worker 时，当 Dapr 运行时启动时，它会检查 Worker 是否存在且是最新的。如果 Worker 不存在，或者它使用的是过时的版本，Dapr 会自动为您创建或升级它。

如果您不想授予 Dapr 为您部署 Worker 脚本的权限，您可以手动配置一个 Worker 供 Dapr 使用。请注意，如果您有多个 Dapr 组件通过 Worker 与 Cloudflare 服务交互，您需要为每个组件创建单独的 Worker。

要手动配置 Worker 脚本，您需要在本地计算机上安装 Node.js。

创建一个新文件夹来放置 Worker 的源代码，例如：daprworker。
如果您还没有这样做，请使用以下命令通过 Wrangler（Cloudflare Workers CLI）进行身份验证：npx wrangler login。
在新创建的文件夹中，创建一个新的 wrangler.toml 文件，内容如下，并适当填写缺失的信息：

# Worker 的名称，例如 "mydaprqueue"
name = ""

# 不要更改这些选项
main = "worker.js"
compatibility_date = "2022-12-09"
usage_model = "bundled"

[vars]
# 将此设置为 Ed25519 密钥的**公钥**部分，PEM 编码（换行符替换为 `\n`）。
# 示例：
# PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowB...=\n-----END PUBLIC KEY-----"
PUBLIC_KEY = ""
# 将此设置为您的 Worker 名称（与上面的 "name" 属性值相同），例如 "mydaprqueue"。
TOKEN_AUDIENCE = ""

# 将接下来的两个值设置为您的 Queue 名称，例如 "myqueue"。
# 注意它们将被设置为相同的值。
[[queues.producers]]
queue = ""
binding = ""

注意：有关如何生成 Ed25519 密钥对，请参阅下一节。在部署 Worker 时，请确保使用密钥的公钥部分！

将 Worker 的（预编译和压缩的）代码复制到 worker.js 文件中。您可以使用以下命令执行此操作：

# 将此设置为您正在使用的 Dapr 版本
DAPR_VERSION="release-1.18"
curl -LfO "https://raw.githubusercontent.com/dapr/components-contrib/${DAPR_VERSION}/internal/component/cloudflare/workers/code/worker.js"

使用 Wrangler 部署 Worker：

npx wrangler publish

部署 Worker 后，您需要使用这两个元数据选项来初始化组件：

workerName：Worker 脚本的名称。这是您在 wrangler.toml 文件中的 name 属性中设置的值。
workerUrl：已部署的 Worker 的 URL。npx wrangler command 命令将向您显示完整的 URL，例如 https://mydaprqueue.mydomain.workers.dev。

生成 Ed25519 密钥对

所有 Cloudflare Workers 都在公共 Internet 上监听，因此 Dapr 需要使用额外的身份验证和数据保护措施，以确保没有其他人员或应用程序可以与您的 Worker 通信（从而与您的 Cloudflare Queue 通信）。这些措施包括行业标准措施，例如：

Dapr 向 Worker 发出的所有请求都通过不记名令牌（技术上讲是 JWT）进行身份验证，该令牌使用 Ed25519 密钥签名。
Dapr 与您的 Worker 之间的所有通信都通过加密连接进行，使用 TLS (HTTPS)。
不记名令牌在每个请求上生成，仅在短时间内有效（目前为一分钟）。

要让 Dapr 颁发不记名令牌并让您的 Worker 验证它们，您需要生成一个新的 Ed25519 密钥对。以下是使用 OpenSSL 或 step CLI 生成密钥对的示例。

自 OpenSSL 1.1.0 起支持生成 Ed25519 密钥，因此如果您使用的是旧版本的 OpenSSL，以下命令将不起作用。

Mac 用户注意：在 macOS 上，Apple 附带的 “openssl” 二进制文件实际上基于 LibreSSL，截至目前它不支持 Ed25519 密钥。如果您使用的是 macOS，请使用 step CLI，或使用 brew install openssl@3 从 Homebrew 安装 OpenSSL 3.0，然后将以下命令中的 openssl 替换为 $(brew --prefix)/opt/openssl@3/bin/openssl。

您可以使用 OpenSSL 生成新的 Ed25519 密钥对：

openssl genpkey -algorithm ed25519 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem

在 macOS 上，使用来自 Homebrew 的 openssl@3：

$(brew --prefix)/opt/openssl@3/bin/openssl genpkey -algorithm ed25519 -out private.pem
$(brew --prefix)/opt/openssl@3/bin/openssl pkey -in private.pem -pubout -out public.pem

如果您还没有 step CLI，请按照官方说明进行安装。

接下来，您可以使用 step CLI 生成新的 Ed25519 密钥对：

step crypto keypair \
  public.pem private.pem \
  --kty OKP --curve Ed25519 \
  --insecure --no-password

无论您如何生成密钥对，按照上述说明，您将拥有两个文件：

private.pem 包含密钥的私钥部分；使用此文件的内容作为组件元数据的**key**属性。
public.pem 包含密钥的公钥部分，仅当您手动部署 Worker 时才需要（按照上一节中的说明）。

警告

请保护密钥的私钥部分并将其视为机密值！

20 - commercetools GraphQL 绑定规范

commercetools GraphQL 绑定组件的详细文档

组件格式

要设置 commercetools GraphQL 绑定，需创建一个类型为 bindings.commercetools 的组件。有关如何创建和应用绑定配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.commercetools
  version: v1
  metadata:
  - name: region # 必填。
    value: "region"
  - name: provider # 必填。
    value: "gcp"
  - name: projectKey # 必填。
    value: "<project-key>"
  - name: clientID # 必填。
    value: "*****************"
  - name: clientSecret # 必填。
    value: "*****************"
  - name: scopes # 必填。
    value: "<project-scopes>"

警告

上述示例将密钥以纯文本字符串形式使用。建议按照此处的说明，使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`region`	Y	输出	commercetools 项目的区域	`"europe-west1"`
`provider`	Y	输出	云提供商，可以是 gcp 或 aws	`"gcp"`, `"aws"`
`projectKey`	Y	输出	commercetools 项目的项目键
`clientID`	Y	输出	项目的 commercetools 客户端 ID
`clientSecret`	Y	输出	项目的 commercetools 客户端密钥
`scopes`	Y	输出	项目的 commercetools 作用域	`"manage_project:project-key"`

更多信息请参阅 commercetools - 创建 API 客户端和 commercetools - 区域。

绑定支持

此组件支持输出绑定，包含以下操作：

create

21 - Cron 绑定规范

Cron 绑定组件的详细文档

组件格式

要设置 Cron 绑定，需创建一个类型为 bindings.cron 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.cron
  version: v1
  metadata:
  - name: schedule
    value: "@every 15m" # 有效的 cron 调度
  - name: direction
    value: "input"

规范元数据字段

字段	必填	绑定支持	详情	示例
`schedule`	Y	Input	要使用的有效 cron 调度。详见此	`"@every 15m"`
`direction`	N	Input	绑定的方向	`"input"`

调度格式

Dapr Cron 绑定支持以下格式：

字符	描述	可接受的值
1	秒	0 到 59，或 *
2	分钟	0 到 59，或 *
3	小时	0 到 23，或 *（UTC）
4	日期	1 到 31，或 *
5	月份	1 到 12，或 *
6	星期	0 到 7（其中 0 和 7 代表星期日），或 *

例如：

30 * * * * * - 每 30 秒
0 */15 * * * * - 每 15 分钟
0 30 3-6,20-23 * * * - 在凌晨 3-6 点和晚上 8-11 点范围内，每小时的第 30 分钟
CRON_TZ=America/New_York 0 30 04 * * * - 纽约时间每天凌晨 4:30

您可以在此了解更多关于 cron 及其支持格式的信息

为方便使用，Dapr Cron 绑定还支持一些快捷方式：

@every 15s，其中 s 表示秒，m 表示分钟，h 表示小时
@daily 或 @hourly，从绑定初始化的时间开始按该周期运行

监听 Cron 绑定

设置 Cron 绑定后，您只需监听与组件名称匹配的端点。假设 [NAME] 为 scheduled。这将通过 HTTP POST 请求发起。以下示例展示了一个简单的 Node.js Express 应用如何在 /scheduled 端点上接收调用并向控制台写入消息。

app.post('/scheduled', async function(req, res){
    console.log("scheduled endpoint called", req.body)
    res.status(200).send()
});

运行此代码时，请注意 /scheduled 端点每 15 分钟会被 Dapr 边车调用一次。

绑定支持

此组件支持输入绑定接口。

22 - Apache Dubbo binding 规范

Apache Dubbo binding 组件的详细文档

组件格式

要设置 Apache Dubbo binding，创建一个类型为 bindings.dubbo 的组件。参见此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.dubbo
  version: v1
  metadata:
    - name: interfaceName
      value: "com.example.UserService"
    - name: methodName
      value: "getUser"
    # 可选
    - name: version
      value: "1.0.0"
    - name: group
      value: "mygroup"
    - name: providerHostname
      value: "localhost"
    - name: providerPort
      value: "8080"

注意

Dubbo binding 默认不需要认证或 secret 配置。但是，如果您的 Dubbo 部署需要安全通信，您可以为敏感值集成 Dapr 的 secret store。

Spec 元数据字段

字段	必需	绑定支持	详情	示例
`interfaceName`	Y	Output	要调用的 Dubbo 接口名称。	`"com.example.UserService"`
`methodName`	Y	Output	在接口上调用的方法名。	`"getUser"`
`version`	N	Output	Dubbo 服务的版本。	`"1.0.0"`
`group`	N	Output	Dubbo 服务的分组名称。	`"mygroup"`
`providerHostname`	N	Output	Dubbo 提供者的主机名。	`"localhost"`
`providerPort`	N	Output	Dubbo 提供者的端口。	`"8080"`

绑定支持

此组件支持输出 binding，具有以下操作：

create：调用 Dubbo 服务方法。

示例：调用 Dubbo 服务

要使用 binding 调用 Dubbo 服务：

{
  "operation": "create",
  "metadata": {
    "interfaceName": "com.example.UserService",
    "methodName": "getUser",
    "version": "1.0.0",
    "providerHostname": "localhost",
    "providerPort": "8080"
  },
  "data": {
    "userId": "12345"
  }
}

data 字段包含发送到 Dubbo 服务方法的请求负载。

23 - GCP Pub/Sub 绑定规范

GCP Pub/Sub 绑定组件的详细文档

组件格式

要设置 GCP Pub/Sub 绑定，请创建类型为 bindings.gcp.pubsub 的组件。有关如何创建和应用绑定配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.gcp.pubsub
  version: v1
  metadata:
  - name: topic
    value: "topic1"
  - name: subscription
    value: "subscription1"
  - name: type
    value: "service_account"
  - name: project_id
    value: "project_111"
  - name: private_key_id
    value: "*************"
  - name: client_email
    value: "name@domain.com"
  - name: client_id
    value: "1111111111111111"
  - name: auth_uri
    value: "https://accounts.google.com/o/oauth2/auth"
  - name: token_uri
    value: "https://oauth2.googleapis.com/token"
  - name: auth_provider_x509_cert_url
    value: "https://www.googleapis.com/oauth2/v1/certs"
  - name: client_x509_cert_url
    value: "https://www.googleapis.com/robot/v1/metadata/x509/<project-name>.iam.gserviceaccount.com"
  - name: private_key
    value: "PRIVATE KEY"
  - name: direction
    value: "input, output"

Warning

上面的示例将密钥作为纯字符串使用。建议使用 secret store 来管理密钥，具体说明请参见此处。

规范元数据字段

字段	必填	绑定支持	详情	示例
`topic`	Y	Output	GCP Pub/Sub topic 名称	`"topic1"`
`subscription`	N	GCP Pub/Sub subscription 名称	`"name1"`
`type`	Y	Output	GCP 凭据类型	`service_account`
`project_id`	Y	Output	GCP 项目 id	`projectId`
`private_key_id`	N	Output	GCP 私钥 id	`"privateKeyId"`
`private_key`	Y	Output	GCP 凭据私钥。替换为 x509 证书	`12345-12345`
`client_email`	Y	Output	GCP 客户端邮箱	`"client@email.com"`
`client_id`	N	Output	GCP 客户端 id	`0123456789-0123456789`
`auth_uri`	N	Output	Google 账户 OAuth 端点	`https://accounts.google.com/o/oauth2/auth`
`token_uri`	N	Output	Google 账户 token uri	`https://oauth2.googleapis.com/token`
`auth_provider_x509_cert_url`	N	Output	GCP 凭据证书 url	`https://www.googleapis.com/oauth2/v1/certs`
`client_x509_cert_url`	N	Output	GCP 凭据项目 x509 证书 url	`https://www.googleapis.com/robot/v1/metadata/x509/<PROJECT_NAME>.iam.gserviceaccount.com`
`direction`	N	Input/Output	绑定的方向。	`"input"`、`"output"`、`"input, output"`

绑定支持

此组件支持 input 和 output 绑定接口。

此组件支持 output 绑定，并具有以下操作：

create

24 - GCP Storage Bucket binding 规范

GCP Storage Bucket binding 组件的详细文档

组件格式

要设置 GCP Storage Bucket binding，请创建类型为 bindings.gcp.bucket 的组件。有关如何创建和应用 binding 配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.gcp.bucket
  version: v1
  metadata:
  - name: bucket
    value: "mybucket"
  - name: type
    value: "service_account"
  - name: project_id
    value: "project_111"
  - name: private_key_id
    value: "*************"
  - name: client_email
    value: "name@domain.com"
  - name: client_id
    value: "1111111111111111"
  - name: auth_uri
    value: "https://accounts.google.com/o/oauth2/auth"
  - name: token_uri
    value: "https://oauth2.googleapis.com/token"
  - name: auth_provider_x509_cert_url
    value: "https://www.googleapis.com/oauth2/v1/certs"
  - name: client_x509_cert_url
    value: "https://www.googleapis.com/robot/v1/metadata/x509/<project-name>.iam.gserviceaccount.com"
  - name: private_key
    value: "PRIVATE KEY"
  - name: decodeBase64
    value: "<bool>"
  - name: encodeBase64
    value: "<bool>"
  - name: contentType
    value: "<string>"

警告

上述示例将密钥作为纯文本字符串使用。建议使用 secret store 来存储密钥，如此处所述。

规范元数据字段

字段	必需	Binding 支持	详细说明	示例
`bucket`	Y	Output	bucket 名称	`"mybucket"`
`project_id`	Y	Output	GCP 项目 ID	`projectId`
`type`	N	Output	GCP 凭据类型	`"service_account"`
`private_key_id`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 文档中的 `private_key_id` 字段	`"privateKeyId"`
`private_key`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `private_key` 字段。替换为 x509 证书	`12345-12345`
`client_email`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `client_email` 字段	`"client@email.com"`
`client_id`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `client_id` 字段	`0123456789-0123456789`
`auth_uri`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `auth_uri` 字段	`https://accounts.google.com/o/oauth2/auth`
`token_uri`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `token_uri` 字段	`https://oauth2.googleapis.com/token`
`auth_provider_x509_cert_url`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `auth_provider_x509_cert_url` 字段	`https://www.googleapis.com/oauth2/v1/certs`
`client_x509_cert_url`	N	Output	如果使用显式凭据，此字段应包含服务账号 json 中的 `client_x509_cert_url` 字段	`https://www.googleapis.com/robot/v1/metadata/x509/<PROJECT_NAME>.iam.gserviceaccount.com`
`decodeBase64`	N	Output	在保存到 bucket 存储之前解码 base64 文件内容的配置。（用于保存二进制内容的文件）。`true` 是唯一允许的肯定值。其他肯定变体如 `"True", "1"` 不可接受。默认为 `false`	`true`, `false`
`encodeBase64`	N	Output	在返回内容之前编码 base64 文件内容的配置。（用于打开二进制内容的文件）。`true` 是唯一允许的肯定值。其他肯定变体如 `"True", "1"` 不可接受。默认为 `false`	`true`, `false`
`contentType`	N	Output	为 bucket 中创建的对象设置的 MIME 类型。如果未指定，GCP 将尝试自动检测内容类型。	`"text/csv"`, `"application/json"`, `"image/png"`

GCP 凭据

由于 GCP Storage Bucket 组件使用 GCP Go 客户端库，默认情况下它使用 Application Default Credentials 进行身份验证。这在 Authenticate to GCP Cloud services using client libraries 指南中有进一步说明。此外，请参阅如何设置 Application Default Credentials。

GCP 凭据

Binding 支持

此组件支持以下操作的输出 binding：

create : 创建文件
get : 获取文件
bulkGet : 批量获取对象
delete : 删除文件
list: 列出文件
copy: 复制文件
move: 移动文件
rename: 重命名文件

创建文件

要执行 create 操作，使用 POST 方法调用 GCP Storage Bucket binding 并提供以下 JSON 请求体：

注意：默认情况下会生成一个随机 UUID。有关设置名称的元数据支持，请参见下文

{
  "operation": "create",
  "data": "YOUR_CONTENT"
}

元数据参数包括：

key - （可选）对象的名称
decodeBase64 - （可选）在保存到存储之前解码 base64 文件内容的配置
contentType - （可选）正在创建的对象的 MIME 类型

示例

将文本保存到随机生成的 UUID 文件

在 Windows 上，使用 cmd 提示符（PowerShell 具有不同的转义机制）

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文本保存到指定文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"key\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "key": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

保存具有正确内容类型的 CSV 文件

curl -d "{ \"operation\": \"create\", \"data\": \"$(cat data.csv | base64)\", \"metadata\": { \"key\": \"data.csv\", \"contentType\": \"text/csv\", \"decodeBase64\": \"true\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "'"$(base64 < data.csv)"'", "metadata": { "key": "data.csv", "contentType": "text/csv", "decodeBase64": "true" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

上传文件

要上传文件，将文件内容作为数据负载传递；对于二进制内容，您可能需要对其进行 Base64 编码。

然后您可以像往常一样上传它：

curl -d "{ \"operation\": \"create\", \"data\": \"(YOUR_FILE_CONTENTS)\", \"metadata\": { \"key\": \"my-test-file.jpg\", \"contentType\": \"image/jpeg\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "$(cat my-test-file.jpg | base64)", "metadata": { "key": "my-test-file.jpg", "contentType": "image/jpeg", "decodeBase64": "true" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体将包含以下 JSON：

{
    "objectURL":"https://storage.googleapis.com/<your bucket>/<key>",
}

获取对象

要执行 get 文件操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数包括：

key - 对象的名称
encodeBase64 - （可选）在返回内容之前编码 base64 文件内容的配置。

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含存储在对象中的值。

批量获取对象

要执行一次性检索所有 bucket 文件的批量获取操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "bulkGet",
}

元数据参数包括：

encodeBase64 - （可选）在返回所有文件的内容之前编码 base64 文件内容的配置

示例

curl -d '{ \"operation\": \"bulkget\"}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "bulkget"}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含一个对象数组，其中每个对象代表 bucket 中的一个文件，具有以下结构：

[
  {
    "name": "file1.txt",
    "data": "content of file1",
    "attrs": {
      "bucket": "mybucket",
      "name": "file1.txt",
      "size": 1234,
      ...
    }
  },
  {
    "name": "file2.txt",
    "data": "content of file2",
    "attrs": {
      "bucket": "mybucket",
      "name": "file2.txt",
      "size": 5678,
      ...
    }
  }
]

数组中的每个对象包含：

name：文件名
data：文件内容
attrs：来自 GCP Storage 的对象属性，包括创建时间、大小、内容类型等元数据

删除对象

要执行 delete 对象操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数包括：

key - 对象的名称

示例

删除对象

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

如果成功，将返回 HTTP 204 (No Content) 和空响应体。

列出对象

要执行 list 对象操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "list",
  "data": {
    "maxResults": 10,
    "prefix": "file",
    "delimiter": "i0FvxAn2EOEL6"
  }
}

数据参数包括：

maxResults - （可选）设置响应中返回的键的最大数量。默认情况下，操作最多返回 1,000 个键名。响应可能包含较少的键，但绝不会包含更多。
prefix - （可选）可用于过滤以 prefix 开头的对象。
delimiter - （可选）可用于将结果限制为给定"目录"中的对象。如果没有 delimiter，则返回 prefix 下的整个树

响应

响应体包含找到的对象列表。

对象列表将以以下形式的 JSON 数组返回：

[
	{
		"Bucket": "<your bucket>",
		"Name": "02WGzEdsUWNlQ",
		"ContentType": "image/png",
		"ContentLanguage": "",
		"CacheControl": "",
		"EventBasedHold": false,
		"TemporaryHold": false,
		"RetentionExpirationTime": "0001-01-01T00:00:00Z",
		"ACL": null,
		"PredefinedACL": "",
		"Owner": "",
		"Size": 5187,
		"ContentEncoding": "",
		"ContentDisposition": "",
		"MD5": "aQdLBCYV0BxA51jUaxc3pQ==",
		"CRC32C": 1058633505,
		"MediaLink": "https://storage.googleapis.com/download/storage/v1/b/<your bucket>/o/02WGzEdsUWNlQ?generation=1631553155678071&alt=media",
		"Metadata": null,
		"Generation": 1631553155678071,
		"Metageneration": 1,
		"StorageClass": "STANDARD",
		"Created": "2021-09-13T17:12:35.679Z",
		"Deleted": "0001-01-01T00:00:00Z",
		"Updated": "2021-09-13T17:12:35.679Z",
		"CustomerKeySHA256": "",
		"KMSKeyName": "",
		"Prefix": "",
		"Etag": "CPf+mpK5/PICEAE="
	}
]

复制对象

要执行 copy 对象操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "copy",
  "metadata": {
    "key": "source-file.txt",
    "destinationBucket": "destination-bucket-name"
  }
}

元数据参数包括：

key - 源对象的名称（必需）
destinationBucket - 目标 bucket 的名称（必需）

移动对象

要执行 move 对象操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "move",
  "metadata": {
    "key": "source-file.txt",
    "destinationBucket": "destination-bucket-name"
  }
}

元数据参数包括：

key - 源对象的名称（必需）
destinationBucket - 目标 bucket 的名称（必需）

重命名对象

要执行 rename 对象操作，使用 POST 方法调用 GCP bucket binding 并提供以下 JSON 请求体：

{
  "operation": "rename",
  "metadata": {
    "key": "old-name.txt",
    "newName": "new-name.txt"
  }
}

元数据参数包括：

key - 对象的当前名称（必需）
newName - 对象的新名称（必需）

25 - GraphQL 绑定规范

GraphQL 绑定组件的详细文档

组件格式

要设置 GraphQL 绑定，请创建一个类型为 bindings.graphql 的组件。有关如何创建和应用绑定配置的说明，请参阅此指南。为了将普通配置设置（例如 endpoint）与 headers 分开，在 header 名称上使用 “header:” 作为前缀。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: example.bindings.graphql
spec:
  type: bindings.graphql
  version: v1
  metadata:
    - name: endpoint
      value: "http://localhost:8080/v1/graphql"
    - name: header:x-hasura-access-key
      value: "adminkey"
    - name: header:Cache-Control
      value: "no-cache"

Warning

上述示例将密钥作为纯字符串使用。建议按照此处所述使用密钥存储来管理密钥。

规范元数据字段

Field	Required	Binding support	Details	Example
`endpoint`	Y	Output	GraphQL 端点字符串更多详细信息请参阅此处	`"http://localhost:4000/graphql/graphql"`
`header:[HEADERKEY]`	N	Output	GraphQL header。在 `name` 中指定 header 键，在 `value` 中指定 header 值。	`"no-cache"`（见上文）
`variable:[VARIABLEKEY]`	N	Output	GraphQL 查询变量。在 `name` 中指定变量名，在 `value` 中指定变量值。	`"123"`（见下文）

GraphQL 绑定内部使用 GraphQL client。

绑定支持

此组件支持输出绑定，具有以下操作：

query
mutation

query

query 操作用于 query 语句，它返回元数据以及以行值数组形式的数据。

请求

in := &dapr.InvokeBindingRequest{
Name:      "example.bindings.graphql",
Operation: "query",
Metadata: map[string]string{ "query": `query { users { name } }`},
}

要使用需要查询变量的 query，请向 metadata 映射添加一个键值对，其中对应于查询变量的每个键都是以 variable: 为前缀的变量名称

in := &dapr.InvokeBindingRequest{
Name: "example.bindings.graphql",
Operation: "query",
Metadata: map[string]string{ 
  "query": `query HeroNameAndFriends($episode: string!) { hero(episode: $episode) { name } }`,
  "variable:episode": "JEDI",
}

26 - HTTP binding 规范

HTTP binding 组件的详细文档

备选方案

服务调用 API 允许调用非 Dapr HTTP 端点，是推荐的方式。阅读 “如何操作：使用 HTTP 调用非 Dapr 端点” 了解更多信息。

配置 Dapr 组件

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.http
  version: v1
  metadata:
    - name: url
      value: "http://something.com"
    #- name: maxResponseBodySize
    #  value: "100Mi" # 可选，从响应中读取的最大数据量
    #- name: MTLSRootCA
    #  value: "/Users/somepath/root.pem" # 可选，根 CA 路径或 PEM 编码字符串
    #- name: MTLSClientCert
    #  value: "/Users/somepath/client.pem" # 可选，客户端证书路径或 PEM 编码字符串
    #- name: MTLSClientKey
    #  value: "/Users/somepath/client.key" # 可选，客户端密钥路径或 PEM 编码字符串
    #- name: MTLSRenegotiation
    #  value: "RenegotiateOnceAsClient" # 可选，可选值之一：RenegotiateNever、RenegotiateOnceAsClient、RenegotiateFreelyAsClient
    #- name: securityToken # 可选，<作为头部包含在 HTTP 请求中的令牌>
    #  secretKeyRef:
    #    name: mysecret
    #    key: "mytoken"
    #- name: securityTokenHeader
    #  value: "Authorization: Bearer" # 可选，<安全令牌的头部名称>
    #- name: errorIfNot2XX
    #  value: "false" # 可选

规范元数据字段

字段	必填	Binding 支持	详情	示例
`url`	Y	输出	要调用的 HTTP 端点的基础 URL	`http://host:port/path`、`http://myservice:8000/customers`
`maxResponseBodySize`	N	输出	要读取的响应的最大长度。整数被解释为字节；为方便起见，可以添加 `Ki, Mi, Gi`（SI）或 `k	M
`MTLSRootCA`	N	输出	根 CA 证书路径或 PEM 编码字符串
`MTLSClientCert`	N	输出	客户端证书路径或 PEM 编码字符串
`MTLSClientKey`	N	输出	客户端私钥路径或 PEM 编码字符串
`MTLSRenegotiation`	N	输出	要使用的 mTLS 重新协商类型	`RenegotiateOnceAsClient`
`securityToken`	N	输出	要作为头部添加到 HTTP 请求的令牌值。与 `securityTokenHeader` 一起使用
`securityTokenHeader`	N	输出	HTTP 请求上 `securityToken` 的头部名称
`errorIfNot2XX`	N	输出	当响应不在 2xx 范围内时是否应抛出 binding 错误。默认为 `true`

MTLSRootCA、MTLSClientCert 和 MTLSClientKey 的值可以通过三种方式提供：

secret store 引用：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.http
  version: v1
  metadata:
  - name: url
    value: http://something.com
  - name: MTLSRootCA
    secretKeyRef:
      name: mysecret
      key: myrootca
auth:
  secretStore: <NAME_OF_SECRET_STORE_COMPONENT>

文件路径：可以将文件的绝对路径作为字段的值提供。
PEM 编码字符串：也可以将 PEM 编码的字符串作为字段的值提供。

注意

元数据字段 MTLSRootCA、MTLSClientCert 和 MTLSClientKey 用于配置 mTLS 认证。要使用 mTLS 认证，必须提供所有三个字段。有关更多详细信息，请参阅 mTLS。您也可以仅提供 MTLSRootCA，以启用由自定义 CA 签名的证书的 HTTPS 连接。有关更多详细信息，请参阅 HTTPS 部分。

Binding 支持

此组件支持 输出 binding，支持以下 HTTP 方法/动词：

create ：出于向后兼容性考虑，被视为 post
get ：读取数据/记录
head ：与 get 相同，但服务器不返回响应体
post ：通常用于创建记录或发送命令
put ：更新数据/记录
patch ：有时用于更新记录的字段子集
delete ：删除数据/记录
options ：请求有关可用通信选项的信息（不常用）
trace ：用于调用远程的应用层请求消息回送（不常用）

请求

操作元数据字段

上述所有操作都支持以下元数据字段

字段	必填	详情	示例
`path`	N	要附加到基础 URL 的路径。用于访问特定的 URI。	`"/1234"`、`"/search?lastName=Jones"`
首字母大写的字段	N	任何首字母大写的字段都将作为请求头部发送	`"Content-Type"`、`"Accept"`

检索数据

要从 HTTP 端点检索数据，请使用 GET 方法调用 HTTP binding 并使用以下 JSON 正文：

{
  "operation": "get"
}

可以选择指定路径以与资源 URI 交互：

{
  "operation": "get",
  "metadata": {
    "path": "/things/1234"
  }
}

响应

响应正文包含 HTTP 端点返回的数据。data 字段包含 HTTP 响应正文，作为字节切片（通过 curl 进行 Base64 编码）。metadata 字段包含：

字段	必填	详情	示例
`statusCode`	Y	HTTP 状态码	`200`、`404`、`503`
`status`	Y	状态描述	`"200 OK"`、`"201 Created"`
首字母大写的字段	N	任何首字母大写的字段都将作为请求头部发送	`"Content-Type"`

示例

请求基础 URL

curl -d "{ \"operation\": \"get\" }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

请求特定路径

curl -d "{ \"operation\": \"get\", \"metadata\": { \"path\": \"/things/1234\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "path": "/things/1234" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

发送和更新数据

要向 HTTP 端点发送数据，请使用 POST、PUT 或 PATCH 方法调用 HTTP binding 并使用以下 JSON 正文：

注意

任何以大写字母开头的元数据字段都将作为请求头部传递。例如，默认的内容类型为 application/json; charset=utf-8。可以通过设置 Content-Type 元数据字段来覆盖。

{
  "operation": "post",
  "data": "content (default is JSON)",
  "metadata": {
    "path": "/things",
    "Content-Type": "application/json; charset=utf-8"
  }
}

示例

发布新记录

curl -d "{ \"operation\": \"post\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"path\": \"/things\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "post", "data": "YOUR_BASE_64_CONTENT", "metadata": { "path": "/things" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

使用 HTTPS

通过配置 Dapr 边车以信任服务器的 SSL 证书，HTTP binding 也可以与 HTTPS 端点一起使用。

将 binding URL 更新为使用 https 而不是 http。
如果需要添加自定义 TLS 证书，请参阅如何操作：在 Dapr 边车中安装证书，在边车中安装 TLS 证书。

示例

更新 binding 组件

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
  namespace: <NAMESPACE>
spec:
  type: bindings.http
  version: v1
  metadata:
  - name: url
    value: https://my-secured-website.com # 使用 HTTPS

在边车中安装 TLS 证书

当边车未在容器内运行时，TLS 证书可以直接安装在主机操作系统上。

以下是边车作为容器运行时的示例。SSL 证书位于主机上的 /tmp/ssl/cert.pem。

version: '3'
services:
  my-app:
    # ...
  dapr-sidecar:
    image: "daprio/daprd:1.8.0"
    command: [
      "./daprd",
     "-app-id", "myapp",
     "-app-port", "3000",
     ]
    volumes:
        - "./components/:/components"
        - "/tmp/ssl/:/certificates" # 将证书文件夹挂载到边车容器的 /certificates
    environment:
      - "SSL_CERT_DIR=/certificates" # 将环境变量设置为证书文件夹的路径
    depends_on:
      - my-app

边车可以从各种源读取 TLS 证书。有关更多信息，请参阅如何操作：将 Pod 卷挂载到 Dapr 边车。在此示例中，我们将 TLS 证书存储为 Kubernetes secret。

kubectl create secret generic myapp-cert --from-file /tmp/ssl/cert.pem

下面的 YAML 是 Kubernetes 部署的示例，该部署将上述 secret 挂载到边车，并设置 SSL_CERT_DIR 以安装证书。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: default
  labels:
    app: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "myapp"
        dapr.io/app-port: "8000"
        dapr.io/volume-mounts: "cert-vol:/certificates" # 将证书文件夹挂载到边车容器的 /certificates
        dapr.io/env: "SSL_CERT_DIR=/certificates" # 将环境变量设置为证书文件夹的路径
    spec:
      volumes:
        - name: cert-vol
          secret:
            secretName: myapp-cert
...

安全地调用 binding

curl -d "{ \"operation\": \"get\" }" \
      https://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get" }' \
      https://localhost:<dapr-port>/v1.0/bindings/<binding-name>

注意

还可以使用 MTLSRootCA 元数据选项配置 HTTPS binding 支持。这将把指定的证书添加到 binding 的受信任证书列表中。两种方法没有特定的偏好。虽然 MTLSRootCA 选项易于使用且不需要对边车进行任何更改，但它仅接受一个证书。如果您需要信任多个证书，则需要按照上述步骤在边车中安装它们。

使用 mTLS 或在 HTTPS 的同时启用客户端 TLS 认证

您可以通过在 binding 组件中提供 MTLSRootCA、MTLSClientCert 和 MTLSClientKey 元数据字段，将 HTTP binding 配置为使用 mTLS 或客户端 TLS 认证以及 HTTPS。

这些字段可以作为文件路径或 pem 编码字符串传递：

如果提供文件路径，则读取文件并使用其内容。
如果提供 PEM 编码的字符串，则按原样使用该字符串。

配置这些字段后，Dapr 边车使用提供的证书在 TLS 握手过程中向服务器验证自身。

如果远程服务器强制执行 TLS 重新协商，您还需要设置元数据字段 MTLSRenegotiation。此字段接受以下选项之一：

RenegotiateNever
RenegotiateOnceAsClient
RenegotiateFreelyAsClient

有关更多详细信息，请参阅 Go RenegotiationSupport 文档。

当配置 HTTP binding 进行通信的服务器需要 mTLS 或客户端 TLS 认证时，您可以使用此功能。

27 - Huawei OBS binding 规范

Huawei OBS binding 组件的详细文档

组件格式

要设置 Huawei Object Storage Service (OBS)（输出）binding，请创建类型为 bindings.huawei.obs 的组件。有关如何创建和应用 binding 配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.huawei.obs
  version: v1
  - name: bucket
    value: "<your-bucket-name>"
  - name: endpoint
    value: "<obs-bucket-endpoint>"
  - name: accessKey
    value: "<your-access-key>"
  - name: secretKey
    value: "<your-secret-key>"
  # optional fields
  - name: region
    value: "<your-bucket-region>"

警告

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体方法请参阅此处。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`bucket`	Y	Output	要写入的 Huawei OBS bucket 名称	`"My-OBS-Bucket"`
`endpoint`	Y	Output	特定的 Huawei OBS 端点	`"obs.cn-north-4.myhuaweicloud.com"`
`accessKey`	Y	Output	访问此资源的 Huawei Access Key (AK)	`"************"`
`secretKey`	Y	Output	访问此资源的 Huawei Secret Key (SK)	`"************"`
`region`	N	Output	bucket 的特定华为区域	`"cn-north-4"`

Binding 支持

此组件支持输出 binding，包含以下操作：

create：创建文件
upload：上传文件
get：获取文件
delete：删除文件
list：列出文件

创建文件

要执行创建操作，请使用 POST 方法调用 Huawei OBS binding，并传入以下 JSON 请求体：

注意：默认情况下会生成一个随机的 UUID。有关设置目标文件名的元数据支持，请参见下文

{
  "operation": "create",
  "data": "YOUR_CONTENT"
}

示例

将文本保存到随机生成的 UUID 文件

在 Windows 上，请使用 cmd 提示符（PowerShell 具有不同的转义机制）

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

将文本保存到特定文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"key\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "key": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应 JSON 请求体包含 statusCode 和 versionId 字段。仅当启用了 bucket 版本控制时，versionId 才会返回值，否则为空字符串。

上传文件

要上传二进制文件（例如 .jpg、.zip），请使用 POST 方法调用 Huawei OBS binding，并传入以下 JSON 请求体：

注意：如果您未指定 key，默认情况下会生成一个随机 UUID。有关设置目标文件名的元数据支持，请参见以下示例。此 API 可用于上传常规文件，例如纯文本文件。

{
  "operation": "upload",
  "metadata": {
     "key": "DESTINATION_FILE_NAME"
   },
  "data": {
     "sourceFile": "PATH_TO_YOUR_SOURCE_FILE"
   }
}

示例

curl -d "{ \"operation\": \"upload\", \"data\": { \"sourceFile\": \".\my-test-file.jpg\" }, \"metadata\": { \"key\": \"my-test-file.jpg\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "upload", "data": { "sourceFile": "./my-test-file.jpg" }, "metadata": { "key": "my-test-file.jpg" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应 JSON 请求体包含 statusCode 和 versionId 字段。仅当启用了 bucket 版本控制时，versionId 才会返回值，否则为空字符串。

获取对象

要执行获取文件操作，请使用 POST 方法调用 Huawei OBS binding，并传入以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数包括：

key - 对象的名称

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应请求体包含存储在对象中的值。

删除对象

要执行删除对象操作，请使用 POST 方法调用 Huawei OBS binding，并传入以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "key": "my-test-file.txt"
  }
}

元数据参数包括：

key - 对象的名称

示例

删除对象

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"key\": \"my-test-file.txt\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "key": "my-test-file.txt" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

成功时返回 HTTP 204（No Content）和空请求体。

列出对象

要执行列出对象操作，请使用 POST 方法调用 Huawei OBS binding，并传入以下 JSON 请求体：

{
  "operation": "list",
  "data": {
    "maxResults": 5,
    "prefix": "dapr-",
    "marker": "obstest",
    "delimiter": "jpg"
  }
}

数据参数包括：

maxResults -（可选）设置响应中返回的最大键数。默认情况下，此操作最多返回 1,000 个键名。响应可能包含较少的键，但绝不会包含更多。
prefix -（可选）将响应限制为以指定前缀开头的键。
marker -（可选）marker 是您希望 Huawei OBS 开始列出的位置。Huawei OBS 从此指定的键之后开始列出。Marker 可以是 bucket 中的任何键。然后在后续调用中可以使用 marker 值来请求下一组列表项。
delimiter -（可选）分隔符是用于对键进行分组的字符。它返回的对象/文件的键不同于由分隔符模式指定的键。

示例

curl -d '{ \"operation\": \"list\", \"data\": { \"maxResults\": 5, \"prefix\": \"dapr-\", \"marker\": \"obstest\", \"delimiter\": \"jpg\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "list", "data": { "maxResults": 5, "prefix": "dapr-", "marker": "obstest", "delimiter": "jpg" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应请求体包含找到的对象列表。

28 - InfluxDB 绑定规范

InfluxDB 绑定组件的详细文档

组件格式

要设置 InfluxDB 绑定，请创建一个类型为 bindings.influx 的组件。有关如何创建和应用绑定配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.influx
  version: v1
  metadata:
  - name: url # 必填
    value: "<INFLUX-DB-URL>"
  - name: token # 必填
    value: "<TOKEN>"
  - name: org # 必填
    value: "<ORG>"
  - name: bucket # 必填
    value: "<BUCKET>"

警告

上述示例将密钥作为纯字符串使用。建议按照此处所述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`url`	Y	Output	InfluxDB 实例的 URL	`"http://localhost:8086"`
`token`	Y	Output	InfluxDB 的授权令牌	`"mytoken"`
`org`	Y	Output	InfluxDB 组织	`"myorg"`
`bucket`	Y	Output	要写入的 Bucket 名称	`"mybucket"`

绑定支持

此组件支持输出绑定，包含以下操作：

create
query

查询

要查询 InfluxDB，请使用 query 操作，并在调用元数据中提供一个 raw 键，其值为查询语句：

curl -X POST http://localhost:3500/v1.0/bindings/myInfluxBinding \
  -H "Content-Type: application/json" \
  -d "{
        \"metadata\": {
          \"raw\": "SELECT * FROM 'sith_lords'"
        },
        \"operation\": \"query\"
      }"

29 - Kafka 绑定规范

Kafka 绑定组件的详细文档

组件格式

要设置 Kafka 绑定，请创建一个类型为 bindings.kafka 的组件。有关如何创建和应用绑定配置，请参阅本指南。有关使用 secretKeyRef 的详细信息，请参阅如何在组件中引用密钥指南。

所有组件元数据字段值都可以携带模板化元数据值，这些值在 Dapr 边车启动时解析。例如，您可以选择使用 {namespace} 作为 consumerGroup，以便在不同的命名空间中使用相同的主题和相同的 appId，如本文中所述。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: kafka-binding
spec:
  type: bindings.kafka
  version: v1
  metadata:
  - name: topics # 可选。用于输入绑定。
    value: "topic1,topic2"
  - name: brokers # 必需。
    value: "localhost:9092,localhost:9093"
  - name: consumerGroup # 可选。用于输入绑定。
    value: "group1"
  - name: publishTopic # 可选。用于输出绑定。
    value: "topic3"
  - name: authRequired # 必需。
    value: "true"
  - name: saslUsername # 当 authRequired 为 `true` 时必需。
    value: "user"
  - name: saslPassword # 当 authRequired 为 `true` 时必需。
    secretKeyRef:
      name: kafka-secrets
      key: "saslPasswordSecret"
  - name: saslMechanism
    value: "SHA-512"
  - name: initialOffset # 可选。用于输入绑定。
    value: "newest"
  - name: maxMessageBytes # 可选。
    value: "1024"
  - name: heartbeatInterval # 可选。
    value: 5s
  - name: sessionTimeout # 可选。
    value: 15s
  - name: version # 可选。
    value: "2.0.0"
  - name: direction
    value: "input, output"
  - name: schemaRegistryURL # 可选。使用 Schema Registry Avro 序列化/反序列化时。Schema Registry URL。
    value: http://localhost:8081
  - name: schemaRegistryAPIKey # 可选。使用 Schema Registry Avro 序列化/反序列化时。Schema Registry API Key。
    value: XYAXXAZ
  - name: schemaRegistryAPISecret # 可选。使用 Schema Registry Avro 序列化/反序列化时。Schema Registry 凭证 API Secret。
    value: "ABCDEFGMEADFF"
  - name: schemaCachingEnabled # 可选。使用 Schema Registry Avro 序列化/反序列化时。启用 schema 缓存。
    value: true
  - name: schemaLatestVersionCacheTTL # 可选。使用 Schema Registry Avro 序列化/反序列化时。使用可用最新 schema 发布消息时 schema 缓存的 TTL。
    value: 5m
  - name: escapeHeaders # 可选。
    value: false

规范元数据字段

字段	必需	绑定支持	详细说明	示例
`topics`	N	输入	以逗号分隔的主题字符串。	`"mytopic1,topic2"`
`brokers`	Y	输入/输出	以逗号分隔的 Kafka broker 字符串。	`"localhost:9092,dapr-kafka.myapp.svc.cluster.local:9093"`
`clientID`	N	输入/输出	用户提供的字符串，随每个请求发送到 Kafka broker，用于日志记录、调试和审计目的。	`"my-dapr-app"`
`consumerGroup`	N	输入	用于监听的 Kafka 消费者组。发布到主题的每条记录都会传递给订阅该主题的每个消费者组中的一个消费者。	`"group1"`
`consumeRetryEnabled`	N	输入/输出	通过设置为 `"true"` 来启用消费重试。在 Kafka 绑定组件中默认为 `false`。	`"true"`, `"false"`
`publishTopic`	Y	输出	要发布到的主题。	`"mytopic"`
`authRequired`	N	已弃用	使用 Kafka broker 启用 SASL 身份验证。	`"true"`, `"false"`
`authType`	Y	输入/输出	配置或禁用身份验证。支持的值：`none`、`password`、`mtls`、`oidc` 或 `oidc_private_key_jwt`	`"password"`, `"none"`
`saslUsername`	N	输入/输出	用于身份验证的 SASL 用户名。仅当 `authRequired` 设置为 `"true"` 时才需要。	`"adminuser"`
`saslPassword`	N	输入/输出	用于身份验证的 SASL 密码。可以是 `secretKeyRef` 以使用密钥引用。仅当 `authRequired` 设置为 `"true"` 时才需要。	`""`, `"KeFg23!"`
`saslMechanism`	N	输入/输出	您想使用的 SASL 身份验证机制。仅当 `authtype` 设置为 `"password"` 时才需要。如果未提供，默认为 `PLAINTEXT`，这可能会导致某些服务（如 Amazon Managed Service for Kafka）中断。	`"SHA-512", "SHA-256", "PLAINTEXT"`
`initialOffset`	N	输入	如果之前未提交偏移量，则使用的初始偏移量。应为 “newest” 或 “oldest”。默认为 “newest”。	`"oldest"`
`maxMessageBytes`	N	输入/输出	单个 Kafka 消息允许的最大字节数。默认为 1024。	`"2048"`
`oidcTokenEndpoint`	N	输入/输出	OAuth2 身份提供者访问令牌端点的完整 URL。当 `authType` 设置为 `oidc` 或 `oidc_private_key_jwt` 时必需	“https://identity.example.com/v1/token"
`oidcClientID`	N	输入/输出	在身份提供者中预配的 OAuth2 客户端 ID。当 `authType` 设置为 `oidc` 或 `oidc_private_key_jwt` 时必需	`"dapr-kafka"`
`oidcClientSecret`	N	输入/输出	在身份提供者中预配的 OAuth2 客户端密钥：当 `authType` 设置为 `oidc` 时必需	`"KeFg23!"`
`oidcScopes`	N	输入/输出	使用访问令牌请求的以逗号分隔的 OAuth2/OIDC 范围列表。当 `authType` 设置为 `oidc` 或 `oidc_private_key_jwt` 时建议使用。默认为 `"openid"`	`"openid,kafka-prod"`
`oidcClientAssertionCert`	N	输入/输出	用于身份验证的 OAuth2 客户端断言证书。当 `authType` 设置为 `oidc_private_key_jwt` 时必需。可以是 `secretKeyRef` 以使用密钥引用	`"-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----"`
`oidcClientAssertionKey`	N	输入/输出	用于身份验证的 OAuth2 客户端断言密钥。当 `authType` 设置为 `oidc_private_key_jwt` 时必需。可以是 `secretKeyRef` 以使用密钥引用	`"-----BEGIN RSA PRIVATE KEY-----\n...\n-----END RSA PRIVATE KEY-----"`
`oidcResource`	N	输入/输出	使用访问令牌请求的 OAuth2 资源。当 `authType` 设置为 `oidc_private_key_jwt` 时建议使用。	`"api://kafka"`
`oidcAudience`	N	输入/输出	使用访问令牌请求的 OAuth2 受众。当 `authType` 设置为 `oidc_private_key_jwt` 时建议使用。	`"http://<idp-host>/realms/local"`
`oidcKid`	N	输入/输出	使用访问令牌请求的 OAuth2 密钥 ID (kid)。当 `authType` 设置为 `oidc_private_key_jwt` 时建议使用。	`"1234567890"`
`version`	N	输入/输出	Kafka 集群版本。默认为 2.0.0。请注意，对于 EventHubs with Kafka，此值必须强制设置为 `1.0.0`。	`"1.0.0"`
`direction`	N	输入/输出	绑定的方向。	`"input"`, `"output"`, `"input, output"`
`oidcExtensions`	N	输入/输出	包含 JSON 编码字典的字符串，表示使用访问令牌请求的 OAuth2/OIDC 扩展	`{"cluster":"kafka","poolid":"kafkapool"}`
`schemaRegistryURL`	N	使用 Schema Registry Avro 序列化/反序列化时必需。Schema Registry URL。	`http://localhost:8081`
`schemaRegistryAPIKey`	N	使用 Schema Registry Avro 序列化/反序列化时。Schema Registry 凭证 API Key。	`XYAXXAZ`
`schemaRegistryAPISecret`	N	使用 Schema Registry Avro 序列化/反序列化时。Schema Registry 凭证 API Secret。	`ABCDEFGMEADFF`
`schemaCachingEnabled`	N	使用 Schema Registry Avro 序列化/反序列化时。启用 schema 缓存。默认为 `true`	`true`
`schemaLatestVersionCacheTTL`	N	使用 Schema Registry Avro 序列化/反序列化时。使用可用最新 schema 发布消息时 schema 缓存的 TTL。默认为 5 分钟	`5m`
`clientConnectionTopicMetadataRefreshInterval`	N	输入/输出	客户端连接的主题元数据与 broker 刷新的时间间隔，以 Go duration 格式表示。默认为 `9m`。	`"4m"`
`clientConnectionKeepAliveInterval`	N	输入/输出	客户端连接在与 broker 保持连接的最大时间，以 Go duration 格式表示，之后将关闭连接。零值（默认）表示无限期保持连接。	`"4m"`
`consumerFetchDefault`	N	输入/输出	在每个请求中从 broker 获取的默认消息字节数。默认为 `"1048576"` 字节。	`"2097152"`
`heartbeatInterval`	N	输入	向消费者协调器发送心跳的间隔。该值最多应设置为 `sessionTimeout` 值的 1/3。默认为 `"3s"`。	`"5s"`
`sessionTimeout`	N	输入	使用 Kafka 的组管理功能时用于检测客户端故障的超时时间。如果 broker 在此会话超时到期前未能收到来自消费者的任何心跳，则消费者将被移除并启动重新平衡。默认为 `"10s"`。	`"20s"`
`escapeHeaders`	N	输入	启用消费者接收的消息标头值的 URL 转义。允许接收通常在 HTTP 标题中不允许的特殊字符内容。默认为 `false`。	`true`

注意

使用 Azure EventHubs with Kafka 时，元数据 version 必须设置为 1.0.0。

绑定支持

此组件同时支持输入和输出绑定接口。

此组件支持以下操作的输出绑定：

create

身份验证

Kafka 支持多种身份验证方案，Dapr 支持其中几种：SASL 密码、mTLS、OIDC/OAuth2。了解有关 Kafka 绑定和 Kafka 发布订阅组件的 Kafka 身份验证方法的更多信息。

指定分区键

调用 Kafka 绑定时，可以通过在请求正文中使用 metadata 部分来提供可选的分区键。

字段名称为 partitionKey。

示例：

curl -X POST http://localhost:3500/v1.0/bindings/myKafka \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "partitionKey": "key1"
        },
        "operation": "create"
      }'

响应

如果成功，将返回 HTTP 204（无内容）和空正文。

30 - Kitex

Kitex binding 组件的详细文档

概述

Kitex 的 binding 主要利用 Kitex 中的 generic-call 功能。更多详情请参考 Kitex generic-call 的官方文档。目前，Kitex 仅支持 Thrift generic calls。集成到 components-contrib 的实现采用 binary generic calls。

组件格式

要设置 Kitex binding，请创建一个类型为 bindings.kitex 的组件。请参阅如何：使用输出 binding 与外部资源交互指南，了解如何创建和应用 binding 配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: bindings.kitex
spec:
  type: bindings.kitex
  version: v1
  metadata: 
  - name: hostPorts
    value: "127.0.0.1:8888"
  - name: destService
    value: "echo"
  - name: methodName
    value: "echo"
  - name: version
    value: "0.5.0"

规范元数据字段

bindings.kitex 的 InvokeRequest.Metadata 要求客户端在进行调用时填写四个必需项：

hostPorts
destService
methodName
version

字段	必填	Binding 支持	详情	示例
`hostPorts`	Y	输出	Kitex 服务器（Thrift）的 IP 地址和端口信息	`"127.0.0.1:8888"`
`destService`	Y	输出	Kitex 服务器（Thrift）的服务名称	`"echo"`
`methodName`	Y	输出	Kitex 服务器（Thrift）特定服务名称下的方法名称	`"echo"`
`version`	Y	输出	Kitex 版本	`"0.5.0"`

Binding 支持

此组件支持输出 binding，支持以下操作：

get

示例

使用 Kitex binding 时：

客户端需要传入正确的 Thrift 编码的二进制数据
服务器需要是 Thrift Server。

kitex_output_test 可作为参考。例如，变量 reqData 需要在发送前由 Thrift 协议_编码_，返回的数据需要由 Thrift 协议解码。

请求

{
  "operation": "get",
  "metadata": {
    "hostPorts": "127.0.0.1:8888",
    "destService": "echo",
    "methodName": "echo",
    "version":"0.5.0"
  },
  "data": reqdata
}

31 - KubeMQ 绑定规范

KubeMQ 绑定组件的详细文档

组件格式

要设置 KubeMQ 绑定，请创建类型为 bindings.kubemq 的组件。请参阅本指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: binding-topic
spec:
  type: bindings.kubemq
  version: v1
  metadata:
    - name: address
      value: "localhost:50000"
    - name: channel
      value: "queue1"
    - name: direction
      value: "input, output"

规范元数据字段

字段	必填	详情	示例
`address`	Y	KubeMQ 服务器的地址	`"localhost:50000"`
`channel`	Y	队列通道名称	`"queue1"`
`authToken`	N	用于连接的身份验证 JWT 令牌。查看 KubeMQ Authentication	`"ew..."`
`autoAcknowledged`	N	设置接收到的队列消息是否自动确认	`"true"` 或 `"false"`（默认为 `"false"`）
`pollMaxItems`	N	设置每次连接时轮询的消息数量	`"1"`
`pollTimeoutSeconds`	N	设置每次轮询间隔的时间（秒）	`"3600"`
`direction`	N	绑定的方向	`"input"`、`"output"`、`"input, output"`

绑定支持

此组件同时支持 输入和输出 绑定接口。

创建 KubeMQ broker

获取 KubeMQ Key。
等待包含您的密钥的邮件确认

您可以使用 Docker 运行 KubeMQ broker：

docker run -d -p 8080:8080 -p 50000:50000 -p 9090:9090 -e KUBEMQ_TOKEN=<your-key> kubemq/kubemq

然后您可以使用客户端端口与服务器交互：localhost:50000

获取 KubeMQ Key。
等待包含您的密钥的邮件确认

然后运行以下 kubectl 命令：

kubectl apply -f https://deploy.kubemq.io/init

kubectl apply -f https://deploy.kubemq.io/key/<your-key>

安装 KubeMQ CLI

访问 KubeMQ CLI 并下载最新版本的 CLI。

浏览 KubeMQ Dashboard

打开浏览器并导航到 http://localhost:8080

安装了 KubeMQCTL 后，运行以下命令：

kubemqctl get dashboard

或者，安装了 kubectl 后，运行 port-forward 命令：

kubectl port-forward svc/kubemq-cluster-api -n kubemq 8080:8080

KubeMQ 文档

访问 KubeMQ Documentation 获取更多信息。

32 - Kubernetes Events 绑定规范

Kubernetes Events 绑定组件的详细文档

组件格式

要设置 Kubernetes Events 绑定，需创建类型为 bindings.kubernetes 的组件。有关如何创建和应用绑定配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.kubernetes
  version: v1
  metadata:
  - name: namespace
    value: "<NAMESPACE>"
  - name: resyncPeriodInSec
    value: "<seconds>"
  - name: direction
    value: "input"

规范元数据字段

字段	是否必填	绑定支持	详细信息	示例
`namespace`	Y	Input	从指定 Kubernetes 命名空间读取事件	`"default"`
`resyncPeriodInSec`	N	Input	从 Kubernetes API 服务器刷新事件列表的时间间隔。默认值为 `"10"`	`"15"`
`direction`	N	Input	绑定的数据流向方向	`"input"`
`kubeconfigPath`	N	Input	kubeconfig 文件的路径。如未指定，绑定将使用默认的集群内配置	`"/path/to/kubeconfig"`

绑定支持

此组件支持输入绑定接口。

输出格式

绑定接收到的输出格式为 bindings.ReadResponse，其中 Data 字段包含如下结构：

 {
   "event": "",
   "oldVal": {
     "metadata": {
       "name": "hello-node.162c2661c524d095",
       "namespace": "kube-events",
       "selfLink": "/api/v1/namespaces/kube-events/events/hello-node.162c2661c524d095",
       ...
     },
     "involvedObject": {
       "kind": "Deployment",
       "namespace": "kube-events",
       ...
     },
     "reason": "ScalingReplicaSet",
     "message": "Scaled up replica set hello-node-7bf657c596 to 1",
     ...
   },
   "newVal": {
     "metadata": { "creationTimestamp": "null" },
     "involvedObject": {},
     "source": {},
     "firstTimestamp": "null",
     "lastTimestamp": "null",
     "eventTime": "null",
     ...
   }
 }

提供三种事件类型：

添加：仅填充 newVal 字段，oldVal 字段为空的 v1.Event，event 值为 add
删除：仅填充 oldVal 字段，newVal 字段为空的 v1.Event，event 值为 delete
更新：同时填充 oldVal 和 newVal 字段，event 值为 update

必需权限

要从 Kubernetes 使用 events，需通过 Kubernetes 的 [RBAC Auth] 机制为用户/组/服务账户分配权限。

角色

需要包含以下规则之一，以授予 get、watch 和 list events 的权限。API 组可根据需要设置为尽可能受限。

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: <ROLENAME>
rules:
- apiGroups: [""]
  resources: ["events"]
  verbs: ["get", "watch", "list"]

RoleBinding

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: <NAME>
subjects:
- kind: ServiceAccount
  name: default # 可根据需要修改
roleRef:
  kind: Role
  name: <ROLENAME> # 与上述名称一致
  apiGroup: ""

33 - Local Storage 绑定规范

Local Storage 绑定组件的详细文档

组件格式

要设置 Local Storage 绑定，请创建一个类型为 bindings.localstorage 的组件。请参阅本指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.localstorage
  version: v1
  metadata:
  - name: rootPath
    value: "<string>"

规范元数据字段

字段	必填	绑定支持	详情	示例
`rootPath`	Y	Output	可读取/保存文件的根路径锚点	`"/temp/files"`

绑定支持

此组件支持输出绑定，包含以下操作：

create : 创建文件
get : 获取文件
list : 列出文件
delete : 删除文件

创建文件

要执行创建文件操作，请使用 POST 方法调用 Local Storage 绑定，并提供以下 JSON 请求体：

注意：默认情况下，会生成一个随机 UUID。请参阅下方的 Metadata 支持以设置名称

{
  "operation": "create",
  "data": "YOUR_CONTENT"
}

示例

保存文本到随机生成的 UUID 文件

在 Windows 上，使用 cmd 提示符（PowerShell 有不同的转义机制）

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

保存文本到指定文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"fileName\": \"my-test-file.txt\" } }" \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "fileName": "my-test-file.txt" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

保存二进制文件

要上传文件，请将其编码为 Base64。绑定会自动检测 Base64 编码。

curl -d "{ \"operation\": \"create\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"fileName\": \"my-test-file.jpg\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "YOUR_BASE_64_CONTENT", "metadata": { "fileName": "my-test-file.jpg" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体将包含以下 JSON：

{
   "fileName": "<filename>"
}

获取文件

要执行获取文件操作，请使用 POST 方法调用 Local Storage 绑定，并提供以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "fileName": "myfile"
  }
}

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"fileName\": \"myfile\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "fileName": "myfile" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含存储在文件中的值。

列出文件

要执行列出文件操作，请使用 POST 方法调用 Local Storage 绑定，并提供以下 JSON 请求体：

{
  "operation": "list"
}

如果您只想列出 rootPath 下特定目录中的文件，请在元数据中将相对目录名称指定为 fileName。

{
  "operation": "list",
  "metadata": {
    "fileName": "my/cool/directory"
  }
}

示例

curl -d '{ \"operation\": \"list\", \"metadata\": { \"fileName\": \"my/cool/directory\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "list", "metadata": { "fileName": "my/cool/directory" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应是一个文件名的 JSON 数组。

删除文件

要执行删除文件操作，请使用 POST 方法调用 Local Storage 绑定，并提供以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "fileName": "myfile"
  }
}

示例

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"fileName\": \"myfile\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "fileName": "myfile" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

如果成功，将返回 HTTP 204（无内容）和空响应体。

元数据信息

默认情况下，Local Storage 输出绑定会自动生成一个 UUID 作为文件名。可以在消息的元数据属性中进行配置。

{
    "data": "file content",
    "metadata": {
        "fileName": "filename.txt"
    },
    "operation": "create"
}

34 - MQTT3 binding 规范

MQTT3 binding 组件的详细文档

组件格式

要设置 MQTT3 binding，请创建一个类型为 bindings.mqtt3 的组件。请参阅此指南了解如何创建和应用 binding 配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.mqtt3
  version: v1
  metadata:
    - name: url
      value: "tcp://[username][:password]@host.domain[:port]"
    - name: topic
      value: "mytopic"
    - name: consumerID
      value: "myapp"
    # 可选
    - name: retain
      value: "false"
    - name: cleanSession
      value: "false"
    - name: backOffMaxRetries
      value: "0"
    - name: direction
      value: "input, output"

警告

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体描述请参见此处。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`url`	Y	Input/Output	MQTT broker 的地址。可以是 `secretKeyRef` 以使用密钥引用。对于非 TLS 通信，使用 `tcp://` URI scheme。对于 TLS 通信，使用 `ssl://` URI scheme。	`"tcp://[username][:password]@host.domain[:port]"`
`topic`	Y	Input/Output	要监听或发送事件的主题。	`"mytopic"`
`consumerID`	Y	Input/Output	用于连接到 MQTT broker 的客户端 ID。	`"myMqttClientApp"`
`retain`	N	Input/Output	定义消息是否由 broker 保存为指定主题的最后一个已知良好值。默认为 `"false"`。	`"true"`, `"false"`
`cleanSession`	N	Input/Output	如果为 `"true"`，则在向 MQTT broker 发送的连接消息中设置 `clean_session` 标志。默认为 `"false"`。	`"true"`, `"false"`
`caCert`	使用 TLS 时必填	Input/Output	PEM 格式的证书颁发机构（CA）证书，用于验证服务器 TLS 证书。	见下方示例
`clientCert`	使用 TLS 时必填	Input/Output	PEM 格式的 TLS 客户端证书。必须与 `clientKey` 一起使用。	见下方示例
`clientKey`	使用 TLS 时必填	Input/Output	PEM 格式的 TLS 客户端密钥。必须与 `clientCert` 一起使用。可以是 `secretKeyRef` 以使用密钥引用。	见下方示例
`backOffMaxRetries`	N	Input	在返回错误之前处理消息的最大重试次数。默认为 `"0"`，表示不进行重试。可以指定 `"-1"` 表示消息应无限重试，直到成功处理或应用程序关闭。组件将在重试之间等待 5 秒。	`"3"`
`direction`	N	Input/Output	binding 的方向	`"input"`, `"output"`, `"input, output"`

使用 TLS 进行通信

要配置使用 TLS 的通信，请确保 MQTT broker（例如 emqx）配置为支持证书，并在组件配置中提供 caCert、clientCert、clientKey 元数据。例如：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: mqtt-binding
spec:
  type: bindings.mqtt3
  version: v1
  metadata:
    - name: url
      value: "ssl://host.domain[:port]"
    - name: topic
      value: "topic1"
    - name: consumerID
      value: "myapp"
    # TLS 配置
    - name: caCert
      value: |
        -----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
    - name: clientCert
      value: |
        -----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
    - name: clientKey
      secretKeyRef:
        name: myMqttClientKey
        key: myMqttClientKey
    # 可选
    - name: retain
      value: "false"
    - name: cleanSession
      value: "false"
    - name: backoffMaxRetries
      value: "0"

请注意，虽然 caCert 和 clientCert 值可能不是密钥，但为了方便，它们也可以从 Dapr 密钥存储中引用。

消费共享主题

当消费共享主题时，每个消费者必须具有唯一标识符。如果运行应用程序的多个实例，您可以使用 {uuid} 标记配置组件的 consumerID 元数据，这将在启动时为每个实例提供随机生成的 consumerID 值。例如：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: mqtt-binding
  namespace: default
spec:
  type: bindings.mqtt3
  version: v1
  metadata:
  - name: consumerID
    value: "{uuid}"
  - name: url
    value: "tcp://admin:public@localhost:1883"
  - name: topic
    value: "topic1"
  - name: retain
    value: "false"
  - name: cleanSession
    value: "true"
  - name: backoffMaxRetries
    value: "0"

警告

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体描述请参见此处。

在这种情况下，每次 Dapr 重启时消费者 ID 的值都是随机的，因此您还应该将 cleanSession 设置为 "true"。

Binding 支持

此组件同时支持 输入和输出 binding 接口。

此组件支持以下操作的 输出 binding：

create：发布新消息

按请求设置主题

您可以在每次请求时覆盖组件元数据中的主题：

{
  "operation": "create",
  "metadata": {
    "topic": "myTopic"
  },
  "data": "<h1>Testing Dapr Bindings</h1>This is a test.<br>Bye!"
}

按请求设置 retain 属性

您可以在每次请求时覆盖组件元数据中的 retain 属性：

{
  "operation": "create",
  "metadata": {
    "retain": "true"
  },
  "data": "<h1>Testing Dapr Bindings</h1>This is a test.<br>Bye!"
}

35 - MySQL & MariaDB 绑定规范

MySQL 绑定组件的详细文档

组件格式

MySQL 绑定允许连接到 MySQL 和 MariaDB 数据库。在本文档中，我们使用"MySQL"来指代这两种数据库。

要设置 MySQL 绑定，需创建一个类型为 bindings.mysql 的组件。请参阅此指南了解如何创建和应用绑定配置。

MySQL 绑定内部使用 Go-MySQL-Driver。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.mysql
  version: v1
  metadata:
    - name: url # 必填，以 DSN 格式定义数据库连接
      value: "<CONNECTION_STRING>"
    - name: pemPath # 可选
      value: "<PEM PATH>"
    - name: maxIdleConns
      value: "<MAX_IDLE_CONNECTIONS>"
    - name: maxOpenConns
      value: "<MAX_OPEN_CONNECTIONS>"
    - name: connMaxLifetime
      value: "<CONNECTION_MAX_LIFE_TIME>"
    - name: connMaxIdleTime
      value: "<CONNECTION_MAX_IDLE_TIME>"

警告

上述示例将密钥以纯文本字符串的形式使用。建议按照此处的描述，使用密钥存储来管理密钥。请注意，你不能仅对用户名/密码使用密钥。如果使用密钥，则必须用于完整的连接字符串。

规范元数据字段

字段	必填	绑定支持	详情	示例
`url`	Y	输出	以数据源名称（DSN）格式表示数据库连接。参见此处的 SSL 详情	`"user:password@tcp(localhost:3306)/dbname"`
`pemPath`	Y	输出	PEM 文件的路径。用于 SSL 连接	`"path/to/pem/file"`
`maxIdleConns`	N	输出	最大空闲连接数。大于 0 的整数	`"10"`
`maxOpenConns`	N	输出	最大打开连接数。大于 0 的整数	`"10"`
`connMaxLifetime`	N	输出	最大连接生存时间。持续时间字符串	`"12s"`
`connMaxIdleTime`	N	输出	最大连接空闲时间。持续时间字符串	`"12s"`

SSL 连接

如果你的服务器需要 SSL，你的连接字符串必须以 &tls=custom 结尾，例如：

"<user>:<password>@tcp(<server>:3306)/<database>?allowNativePasswords=true&tls=custom"

你必须将 <PEM PATH> 替换为 PEM 文件的完整路径。如果你使用的是 Azure Database for MySQL，请参阅 Azure 关于 SSL 数据库连接的文档，了解如何下载所需的证书。与 MySQL 的连接至少需要 TLS 1.2 版本。

多条语句

默认情况下，MySQL Go driver 每个查询/命令仅支持一条 SQL 语句。

要允许在一个查询中使用多条语句，你需要向查询字符串添加 multiStatements=true，例如：

"<user>:<password>@tcp(<server>:3306)/<database>?multiStatements=true"

虽然这允许批量查询，但也大大增加了 SQL 注入的风险。仅返回第一个查询的结果，所有其他结果都被静默丢弃。

绑定支持

此组件支持具有以下操作的输出绑定：

exec
query
close

参数化查询

此绑定支持参数化查询，允许将 SQL 查询本身与用户提供的值分开。出于安全原因，强烈建议使用参数化查询，因为它们可以防止 SQL 注入攻击。

例如：

-- ❌ 错误！在查询中包含值，并且容易受到 SQL 注入攻击。
SELECT * FROM mytable WHERE user_key = 'something';

-- ✅ 正确！使用参数化查询。
-- 这将使用参数 ["something"] 执行
SELECT * FROM mytable WHERE user_key = ?;

exec

exec 操作可用于 DDL 操作（如表创建），以及仅返回元数据（例如受影响的行数）的 INSERT、UPDATE、DELETE 操作。

params 属性是一个包含 JSON 编码参数数组的字符串。

请求

{
  "operation": "exec",
  "metadata": {
    "sql": "INSERT INTO foo (id, c1, ts) VALUES (?, ?, ?)",
    "params": "[1, \"demo\", \"2020-09-24T11:45:05Z07:00\"]"
  }
}

响应

{
  "metadata": {
    "operation": "exec",
    "duration": "294µs",
    "start-time": "2020-09-24T11:13:46.405097Z",
    "end-time": "2020-09-24T11:13:46.414519Z",
    "rows-affected": "1",
    "sql": "INSERT INTO foo (id, c1, ts) VALUES (?, ?, ?)"
  }
}

query

query 操作用于 SELECT 语句，它返回元数据以及以行值数组形式的数据。

params 属性是一个包含 JSON 编码参数数组的字符串。

请求

{
  "operation": "query",
  "metadata": {
    "sql": "SELECT * FROM foo WHERE id < $1",
    "params": "[3]"
  }
}

响应

{
  "metadata": {
    "operation": "query",
    "duration": "432µs",
    "start-time": "2020-09-24T11:13:46.405097Z",
    "end-time": "2020-09-24T11:13:46.420566Z",
    "sql": "SELECT * FROM foo WHERE id < ?"
  },
  "data": [
    {column_name: value, column_name: value, ...},
    {column_name: value, column_name: value, ...},
    {column_name: value, column_name: value, ...},
  ]
}

这里 column_name 是查询返回的列的名称，value 是该列的值。请注意，值作为字符串或数字返回（特定于语言的数据类型）

close

close 操作可用于显式关闭数据库连接并将其返回到连接池。此操作没有任何响应。

请求

{
  "operation": "close"
}

36 - PostgreSQL 绑定规范

PostgreSQL 绑定组件的详细文档

组件格式

要设置 PostgreSQL 绑定，需创建一个类型为 bindings.postgresql 的组件。请参阅此指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.postgresql
  version: v1
  metadata:
    # 连接字符串
    - name: connectionString
      value: "<CONNECTION STRING>"

警告

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用密钥存储来管理密钥。

规范元数据字段

使用连接字符串进行身份验证

使用 PostgreSQL 连接字符串进行身份验证时，以下元数据选项是必需的。

字段	必需	详情	示例
`connectionString`	Y	PostgreSQL 数据库的连接字符串。有关如何定义连接字符串的信息，请参阅 PostgreSQL 关于数据库连接的文档。	`"host=localhost user=postgres password=example port=5432 connect_timeout=10 database=my_db"`

使用单独的连接参数进行身份验证

除了使用连接字符串外，您还可以选择指定单独的连接参数。这些参数等同于标准的 PostgreSQL 连接参数。

字段	必需	详情	示例
`host`	Y	PostgreSQL 服务器的主机名或 IP 地址	`"localhost"`
`hostaddr`	N	PostgreSQL 服务器的 IP 地址（host 的替代选项）	`"127.0.0.1"`
`port`	Y	PostgreSQL 服务器的端口号	`"5432"`
`database`	Y	要连接的数据库名称	`"my_db"`
`user`	Y	用于连接的 PostgreSQL 用户	`"postgres"`
`password`	Y	PostgreSQL 用户的密码	`"example"`
`sslRootCert`	N	SSL 根证书文件的路径	`"/path/to/ca.crt"`

注意

使用单独的连接参数时，这些参数将覆盖 connectionString 中存在的参数。

使用 Microsoft Entra ID 进行身份验证

支持使用 Microsoft Entra ID 对 Azure Database for PostgreSQL 进行身份验证。可以使用 Dapr 支持的所有身份验证方法，包括客户端凭据（“服务主体”）和托管标识。

字段	必需	详情	示例
`useAzureAD`	Y	必须设置为 `true` 以使组件能够从 Microsoft Entra ID 获取访问令牌。	`"true"`
`connectionString`	Y	PostgreSQL 数据库的连接字符串。必须包含用户，该用户对应于在 PostgreSQL 内部创建的映射到 Microsoft Entra ID 标识的用户名称；这通常是相应主体的名称（例如 Microsoft Entra ID 应用程序的名称）。此连接字符串不应包含任何密码。	`"host=mydb.postgres.database.azure.com user=myapplication port=5432 database=my_db sslmode=require"`
`azureTenantId`	N	Microsoft Entra ID 租户的 ID	`"cd4b2887-304c-…"`
`azureClientId`	N	客户端 ID（应用程序 ID）	`"c7dd251f-811f-…"`
`azureClientSecret`	N	客户端密钥（应用程序密码）	`"Ecy3X…"`

使用 AWS IAM 进行身份验证

支持使用 AWS IAM 对所有版本的 PostgreSQL 类型组件进行身份验证。连接字符串中指定的用户必须是数据库中已存在的用户，并且是已授予 rds_iam 数据库角色的 AWS IAM 启用用户。身份验证基于 AWS 身份验证配置文件，或提供的 AccessKey/SecretKey。 AWS 身份验证令牌将在其过期时间之前动态轮换。

字段	必需	详情	示例
`useAWSIAM`	Y	必须设置为 `true` 以使组件能够从 AWS IAM 获取访问令牌。此身份验证方法仅适用于 AWS Relational Database Service for PostgreSQL 数据库。	`"true"`
`connectionString`	Y	PostgreSQL 数据库的连接字符串。必须包含已存在的用户，该用户对应于在 PostgreSQL 内部创建的映射到 AWS IAM 策略的用户名称。此连接字符串不应包含任何密码。请注意，对于 AWS，数据库名称字段由 dbname 表示。	`"host=mydb.postgres.database.aws.com user=myapplication port=5432 dbname=my_db sslmode=require"`
`awsRegion`	N	这保持与现有字段的向后兼容性。它将在 Dapr 1.17 中被弃用。请改用 ‘region’。部署 AWS Relational Database Service 的 AWS 区域。	`"us-east-1"`
`awsAccessKey`	N	这保持与现有字段的向后兼容性。它将在 Dapr 1.17 中被弃用。请改用 ‘accessKey’。与 IAM 账户关联的 AWS 访问密钥	`"AKIAIOSFODNN7EXAMPLE"`
`awsSecretKey`	N	这保持与现有字段的向后兼容性。它将在 Dapr 1.17 中被弃用。请改用 ‘secretKey’。与访问密钥关联的密钥	`"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"`
`awsSessionToken`	N	这保持与现有字段的向后兼容性。它将在 Dapr 1.17 中被弃用。请改用 ‘sessionToken’。要使用的 AWS 会话令牌。仅当您使用临时安全凭证时才需要会话令牌。	`"TOKEN"`

其他元数据选项

字段	必需	绑定支持	详情	示例
`timeout`	N	输出	数据库操作的超时时间，格式为 Go duration。整数将被解释为秒数。默认为 `20s`	`"30s"`, `30`
`maxConns`	N	输出	此组件池化的最大连接数。设置为 0 或更小以使用默认值，默认值为 4 或 CPU 数量中的较大者。	`"4"`
`connectionMaxIdleTime`	N	输出	在连接池中自动关闭未使用连接之前的最大空闲时间。默认情况下，没有此值，由数据库驱动程序选择。	`"5m"`
`queryExecMode`	N	输出	控制执行查询的默认模式。默认情况下，Dapr 使用扩展协议并自动准备和缓存预处理语句。但是，这可能与 PGBouncer 等代理不兼容。在这种情况下，使用 `exec` 或 `simple_protocol` 可能更合适。	`"simple_protocol"`

URL 格式

PostgreSQL 绑定内部使用 pgx connection pool，因此 connectionString 参数可以是任何有效的连接字符串，格式为 DSN 或 URL：

DSN 示例

user=dapr password=secret host=dapr.example.com port=5432 dbname=my_dapr sslmode=verify-ca

URL 示例

postgres://dapr:secret@dapr.example.com:5432/my_dapr?sslmode=verify-ca

这两种方法也支持连接池配置变量：

pool_min_conns: 整数 0 或更大
pool_max_conns: 大于 0 的整数
pool_max_conn_lifetime: 持续时间字符串
pool_max_conn_idle_time: 持续时间字符串
pool_health_check_period: 持续时间字符串

绑定支持

此组件支持输出绑定，具有以下操作：

exec
query
close

参数化查询

此绑定支持参数化查询，允许将 SQL 查询本身与用户提供的值分开。出于安全原因，强烈建议使用参数化查询，因为它们可以防止 SQL 注入攻击。

例如：

-- ❌ 错误！在查询中包含值，并且容易受到 SQL 注入攻击。
SELECT * FROM mytable WHERE user_key = 'something';

-- ✅ 正确！使用参数化查询。
-- 这将使用参数 ["something"] 执行
SELECT * FROM mytable WHERE user_key = $1;

exec

exec 操作可用于 DDL 操作（如表创建），以及仅返回元数据（例如受影响的行数）的 INSERT、UPDATE、DELETE 操作。

params 属性是一个包含 JSON 编码参数数组的字符串。

请求

{
  "operation": "exec",
  "metadata": {
    "sql": "INSERT INTO foo (id, c1, ts) VALUES ($1, $2, $3)",
    "params": "[1, \"demo\", \"2020-09-24T11:45:05Z07:00\"]"
  }
}

响应

{
  "metadata": {
    "operation": "exec",
    "duration": "294µs",
    "start-time": "2020-09-24T11:13:46.405097Z",
    "end-time": "2020-09-24T11:13:46.414519Z",
    "rows-affected": "1",
    "sql": "INSERT INTO foo (id, c1, ts) VALUES ($1, $2, $3)"
  }
}

query

query 操作用于 SELECT 语句，它以行值数组的形式返回数据以及元数据。

params 属性是一个包含 JSON 编码参数数组的字符串。

请求

{
  "operation": "query",
  "metadata": {
    "sql": "SELECT * FROM foo WHERE id < $1",
    "params": "[3]"
  }
}

响应

{
  "metadata": {
    "operation": "query",
    "duration": "432µs",
    "start-time": "2020-09-24T11:13:46.405097Z",
    "end-time": "2020-09-24T11:13:46.420566Z",
    "sql": "SELECT * FROM foo WHERE id < $1"
  },
  "data": "[
    [0,\"test-0\",\"2020-09-24T04:13:46Z\"],
    [1,\"test-1\",\"2020-09-24T04:13:46Z\"],
    [2,\"test-2\",\"2020-09-24T04:13:46Z\"]
  ]"
}

close

close 操作可用于显式关闭数据库连接并将其返回到池中。此操作没有任何响应。

请求

{
  "operation": "close"
}

37 - Postmark binding 规范

Postmark binding 组件的详细文档

组件格式

要设置 Postmark binding，请创建一个类型为 bindings.postmark 的组件。有关如何创建和应用 binding 配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: postmark
spec:
  type: bindings.postmark
  metadata:
  - name: accountToken
    value: "YOUR_ACCOUNT_TOKEN" # 必填，这是您的 Postmark 账户令牌
  - name: serverToken
    value: "YOUR_SERVER_TOKEN" # 必填，这是您的 Postmark 服务器令牌
  - name: emailFrom
    value: "testapp@dapr.io" # 可选
  - name: emailTo
    value: "dave@dapr.io" # 可选
  - name: subject
    value: "Hello!" # 可选

Warning

上述示例使用纯文本字符串形式的密钥。建议按照此处所述使用密钥存储来管理密钥。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`accountToken`	Y	Output	Postmark 账户令牌，应将其视为密钥值	`"account token"`
`serverToken`	Y	Output	Postmark 服务器令牌，应将其视为密钥值	`"server token"`
`emailFrom`	N	Output	如果设置，则指定电子邮件的"发件人"地址	`"me@exmaple.com"`
`emailTo`	N	Output	如果设置，则指定电子邮件的"收件人"地址	`"me@example.com"`
`emailCc`	N	Output	如果设置，则指定电子邮件的"抄送"地址	`"me@example.com"`
`emailBcc`	N	Output	如果设置，则指定电子邮件的"密送"地址	`"me@example.com"`
`subject`	N	Output	如果设置，则指定电子邮件的主题	`"me@example.com"`

您也可以在输出 binding 请求中指定任何可选的元数据属性（例如 emailFrom、emailTo、subject 等）。

综合来看，组件配置和请求负载中的可选元数据属性应至少包含 emailFrom、emailTo 和 subject 字段，因为成功发送电子邮件需要这些字段。

Binding 支持

此组件支持 输出 binding，具有以下操作：

create

示例请求负载

{
  "operation": "create",
  "metadata": {
    "emailTo": "changeme@example.net",
    "subject": "An email from Dapr Postmark binding"
  },
  "data": "<h1>Testing Dapr Bindings</h1>This is a test.<br>Bye!"
}

38 - RabbitMQ 绑定规范

RabbitMQ 绑定组件的详细文档

组件格式

要设置 RabbitMQ 绑定，需创建一个类型为 bindings.rabbitmq 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.rabbitmq
  version: v1
  metadata:
  - name: queueName
    value: "queue1"
  - name: host
    value: "amqp://[username][:password]@host.domain[:port]"
  - name: durable
    value: "true"
  - name: deleteWhenUnused
    value: "false"
  - name: ttlInSeconds
    value: "60"
  - name: prefetchCount
    value: "0"
  - name: exclusive
    value: "false"
  - name: maxPriority
    value: "5"
  - name: contentType
    value: "text/plain"
  - name: reconnectWaitInSeconds
    value: "5"
  - name: externalSasl
    value: "false"
  - name: caCert
    value: "null"
  - name: clientCert
    value: "null"
  - name: clientKey
    value: "null"
  - name: direction 
    value: "input, output"

警告

上述示例使用纯文本字符串作为密钥。建议使用密钥存储来管理密钥，具体操作请参阅此处。

规范元数据字段

当发布新的 RabbitMQ 消息时，关联元数据中的所有值都会被添加到消息的标头值中。

字段	必填	绑定支持	详情	示例
`queueName`	Y	Input/Output	RabbitMQ 队列名称	`"myqueue"`
`host`	Y	Input/Output	RabbitMQ 主机地址	`"amqp://[username][:password]@host.domain[:port]"` 或使用 TLS：`"amqps://[username][:password]@host.domain[:port]"`
`durable`	N	Output	告诉 RabbitMQ 将消息持久化到存储。默认值为 `"false"`	`"true"`, `"false"`
`deleteWhenUnused`	N	Input/Output	启用或禁用自动删除。默认值为 `"false"`	`"true"`, `"false"`
`ttlInSeconds`	N	Output	在 RabbitMQ 队列级别设置默认消息存活时间。如果省略此参数，消息将不会过期，会一直存在于队列中直到被处理。另请参阅此处	`60`
`prefetchCount`	N	Input	设置通道预取设置（QoS）。如果省略此参数，QoS 会将值设置为 0，表示无限制	`0`
`exclusive`	N	Input/Output	确定主题是否为独占主题。默认值为 `"false"`	`"true"`, `"false"`
`maxPriority`	N	Input/Output	用于设置优先级队列的参数。如果省略此参数，队列将创建为常规队列而非优先级队列。值范围为 1 到 255。另请参阅此处	`"1"`, `"10"`
`contentType`	N	Input/Output	消息的内容类型。默认值为 “text/plain”。	`"text/plain"`, `"application/cloudevent+json"` 等
`reconnectWaitInSeconds`	N	Input/Output	表示客户端在断开连接后尝试重新连接到服务器之前应等待的持续时间（秒）。默认值为 `"5"`。	`"5"`, `"10"`
`externalSasl`	N	Input/Output	使用 TLS 时，是否应从额外字段（如 CN）获取用户名。请参阅 RabbitMQ 身份验证机制。默认值为 `"false"`。	`"true"`, `"false"`
`caCert`	N	Input/Output	用于 TLS 连接的 CA 证书。默认值为 `null`。	`"-----BEGIN CERTIFICATE-----\nMI..."`
`clientCert`	N	Input/Output	用于 TLS 连接的客户端证书。默认值为 `null`。	`"-----BEGIN CERTIFICATE-----\nMI..."`
`clientKey`	N	Input/Output	用于 TLS 连接的客户端密钥。默认值为 `null`。	`"-----BEGIN PRIVATE KEY-----\nMI..."`
`direction`	N	Input/Output	绑定的方向。	`"input"`, `"output"`, `"input, output"`

绑定支持

此组件同时支持输入和输出绑定接口。

此组件支持输出绑定，具有以下操作：

create

为每条消息指定 TTL

存活时间可以在队列级别（如上所示）或消息级别定义。在消息级别定义的值会覆盖队列级别设置的任何值。

要在消息级别设置存活时间，请在绑定调用期间使用请求体中的 metadata 部分。

字段名称为 ttlInSeconds。

示例：

curl -X POST http://localhost:3500/v1.0/bindings/myRabbitMQ \
  -H "Content-Type: application/json" \
  -d "{
        \"data\": {
          \"message\": \"Hi\"
        },
        \"metadata\": {
          \"ttlInSeconds\": "60"
        },
        \"operation\": \"create\"
      }"

curl -X POST http://localhost:3500/v1.0/bindings/myRabbitMQ \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "ttlInSeconds": "60"
        },
        "operation": "create"
      }'

为每条消息指定优先级

优先级可以在消息级别定义。如果设置了 maxPriority 参数，高优先级消息将优先于其他低优先级消息。

要在消息级别设置优先级，请在绑定调用期间使用请求体中的 metadata 部分。

字段名称为 priority。

示例：

curl -X POST http://localhost:3500/v1.0/bindings/myRabbitMQ \
  -H "Content-Type: application/json" \
  -d "{
        \"data\": {
          \"message\": \"Hi\"
        },
        \"metadata\": {
          "priority": \"5\"
        },
        \"operation\": \"create\"
      }"

curl -X POST http://localhost:3500/v1.0/bindings/myRabbitMQ \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "message": "Hi"
        },
        "metadata": {
          "priority": "5"
        },
        "operation": "create"
      }'

39 - Redis binding spec

Redis 绑定组件的详细文档

组件格式

要设置 Redis 绑定，需创建一个类型为 bindings.redis 的组件。请参阅本指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.redis
  version: v1
  metadata:
  - name: redisHost
    value: "<address>:6379"
  - name: redisPassword
    value: "**************"
  - name: useEntraID
    value: "true"
  - name: enableTLS
    value: "<bool>"

Warning

上述示例使用明文字符串表示密钥。建议按照此处的说明使用密钥存储来管理密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`redisHost`	Y	输出	redis 主机的连接字符串。如果 `"redisType"` 为 `"cluster"`，可以是多个用逗号分隔的主机或单个主机。使用 Redis Sentinel（`"failover"` 为 `"true"`）时，也可以提供多个 sentinel 地址，用逗号分隔。	`localhost:6379`, `redis-master.default.svc.cluster.local:6379`, `sentinel1:26379,sentinel2:26379,sentinel3:26379`
`redisPassword`	N	输出	Redis 密码	`"password"`
`redisUsername`	N	输出	Redis 主机的用户名。默认为空。请确保您的 redis 服务器版本为 6 或以上，并且已正确创建 acl 规则。	`"username"`
`useEntraID`	N	输出	为 Azure Cache for Redis 实现 EntraID 支持。启用此功能前： `redisHost` 名称必须以 `"server:port"` 的形式指定必须启用 TLS 在创建 Redis 实例 > Azure Cache for Redis下了解有关此设置的更多信息	`"true"`, `"false"`
`enableTLS`	N	输出	如果 Redis 实例支持带有公共证书的 TLS，可以配置为启用或禁用 TLS。默认为 `"false"`	`"true"`, `"false"`
`clientCert`	N	输出	客户端证书的内容，用于需要客户端证书的 Redis 实例。必须与 `clientKey` 一起使用，并且 `enableTLS` 必须设置为 true。建议按照此处的说明使用密钥存储	`"----BEGIN CERTIFICATE-----\nMIIC..."`
`clientKey`	N	输出	客户端私钥的内容，与 `clientCert` 结合使用进行身份验证。建议按照此处的说明使用密钥存储	`"----BEGIN PRIVATE KEY-----\nMIIE..."`
`failover`	N	输出	用于启用故障转移配置的属性。需要设置 sentinelMasterName。启用时，redisHost 应包含 sentinel 地址。默认为 `"false"`	`"true"`, `"false"`
`sentinelMasterName`	N	输出	sentinel 主节点名称。请参阅 Redis Sentinel 文档	`""`, `"mymaster"`
`sentinelUsername`	N	输出	Redis Sentinel 的用户名。仅在 “failover” 为 true 且 Redis Sentinel 已启用身份验证时适用	`"username"`
`sentinelPassword`	N	输出	Redis Sentinel 的密码。仅在 “failover” 为 true 且 Redis Sentinel 已启用身份验证时适用	`"password"`
`redeliverInterval`	N	输出	检查待重新投递消息的间隔时间。默认为 `"60s"`。`"0"` 禁用重新投递。	`"30s"`
`processingTimeout`	N	输出	消息在尝试重新投递前必须保持待处理的时间量。默认为 `"15s"`。`"0"` 禁用重新投递。	`"30s"`
`redisType`	N	输出	redis 的类型。有两个有效值，一个是 `"node"` 用于单节点模式，另一个是 `"cluster"` 用于 redis 集群模式。默认为 `"node"`。	`"cluster"`
`redisDB`	N	输出	连接到 redis 后选择的数据库。如果 `"redisType"` 是 `"cluster"`，则忽略此选项。默认为 `"0"`。	`"0"`
`redisMaxRetries`	N	输出	放弃前重试命令的最大次数。默认不重试失败的命令。	`"5"`
`redisMinRetryInterval`	N	输出	每次重试之间 redis 命令的最小退避时间。默认为 `"8ms"`； `"-1"` 禁用退避。	`"8ms"`
`redisMaxRetryInterval`	N	输出	每次重试之间 redis 命令的最大退避时间。默认为 `"512ms"`；`"-1"` 禁用退避。	`"5s"`
`dialTimeout`	N	输出	建立新连接的拨号超时时间。默认为 `"5s"`。	`"5s"`
`readTimeout`	N	输出	套接字读取超时时间。如果达到超时，redis 命令将以超时失败而不是阻塞。默认为 `"3s"`，`"-1"` 表示无超时。	`"3s"`
`writeTimeout`	N	输出	套接字写入超时时间。如果达到超时，redis 命令将以超时失败而不是阻塞。默认为 readTimeout。	`"3s"`
`poolSize`	N	输出	套接字连接的最大数量。默认为每个 CPU 10 个连接，由 runtime.NumCPU 报告。	`"20"`
`poolTimeout`	N	输出	如果所有连接都忙，客户端等待连接的时间量，然后返回错误。默认为 readTimeout + 1 秒。	`"5s"`
`maxConnAge`	N	输出	连接的年龄，客户端在该年龄后关闭连接。默认不关闭旧连接。	`"30m"`
`minIdleConns`	N	输出	保持打开的最小空闲连接数，以避免与创建新连接相关的性能下降。默认为 `"0"`。	`"2"`
`idleCheckFrequency`	N	输出	空闲连接清理器执行的空闲检查频率。默认为 `"1m"`。 `"-1"` 禁用空闲连接清理器。	`"-1"`
`idleTimeout`	N	输出	客户端关闭空闲连接的时间量。应小于服务器的超时时间。默认为 `"5m"`。 `"-1"` 禁用空闲超时检查。	`"10m"`

绑定支持

此组件支持具有以下操作的输出绑定：

create
get
delete

create

您可以使用 create 操作在 Redis 中存储记录。这将设置一个键来保存一个值。如果该键已存在，则覆盖该值。

请求

{
  "operation": "create",
  "metadata": {
    "key": "key1"
  },
  "data": {
    "Hello": "World",
    "Lorem": "Ipsum"
  }
}

响应

如果成功，返回 HTTP 204（无内容）和空正文。

get

您可以使用 get 操作在 Redis 中获取记录。这将获取一个先前设置的键。

这采用一个可选参数 delete，默认为 false。当设置为 true 时，此操作使用 Redis 的 GETDEL 操作。例如，它返回先前设置的 value 然后删除它。

请求

{
  "operation": "get",
  "metadata": {
    "key": "key1"
  },
  "data": {
  }
}

响应

{
  "data": {
    "Hello": "World",
    "Lorem": "Ipsum"
  }
}

带有 delete 标志的请求

{
  "operation": "get",
  "metadata": {
    "key": "key1",
    "delete": "true"
  },
  "data": {
  }
}

delete

您可以使用 delete 操作在 Redis 中删除记录。无论键是否存在，都返回成功。

请求

{
  "operation": "delete",
  "metadata": {
    "key": "key1"
  }
}

响应

如果成功，返回 HTTP 204（无内容）和空正文。

创建 Redis 实例

Dapr 可以使用任何 Redis 实例 - 容器化、在本地开发机器上运行或托管云服务，只要 Redis 的版本为 5.0.0 或更高版本。

注意：Dapr 不支持 Redis >= 7。建议使用 Redis 6

Dapr CLI 将自动为您创建并设置 Redis Streams 实例。当您运行 dapr init 时，Redis 实例将通过 Docker 安装，组件文件将在默认目录中创建。（$HOME/.dapr/components 目录（Mac/Linux）或 Windows 上的 %USERPROFILE%\.dapr\components）。

您可以使用 Helm 在我们的 Kubernetes 集群中快速创建 Redis 实例。此方法需要安装 Helm。

将 Redis 安装到您的集群中。

helm repo add bitnami https://charts.bitnami.com/bitnami
helm install redis bitnami/redis --set image.tag=6.2

运行 kubectl get pods 以查看 Redis 容器现在正在您的集群中运行。

在您的 redis.yaml 文件中添加 redis-master:6379 作为 redisHost。例如：

    metadata:
    - name: redisHost
      value: redis-master:6379

接下来，我们将获取 Redis 密码，根据我们使用的操作系统略有不同：
- Windows：运行 kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64，这将创建一个包含您的编码密码的文件。接下来，运行 certutil -decode encoded.b64 password.txt，这会将您的 redis 密码放入名为 password.txt 的文本文件中。复制密码并删除这两个文件。
- Linux/MacOS：运行 kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" | base64 --decode 并复制输出的密码。
将此密码作为 redisPassword 值添加到您的 redis.yaml 文件中。例如：
```
    - name: redisPassword
      value: "lhDOkwTlp0"
```

AWS Redis

使用官方 Microsoft 文档创建 Azure Cache for Redis 实例。
实例创建后，从 Azure 门户获取主机名（FQDN）和访问密钥。
- 对于主机名：
  - 导航到资源的概述页面。
  - 复制主机名值。
- 对于访问密钥：
  - 导航到设置 > 访问密钥。
  - 复制并保存您的密钥。
将您的密钥和主机名添加到 Dapr 可以应用到集群的 redis.yaml 文件中。
- 如果您正在运行示例，将主机和密钥添加到提供的 redis.yaml 中。
- 如果您从头开始创建项目，请按照组件格式部分中的说明创建 redis.yaml 文件。
将 redisHost 键设置为 [上一步的主机名]:6379，将 redisPassword 键设置为您之前保存的密钥。
**注意：**在生产级应用程序中，请遵循密钥管理说明来安全地管理您的密钥。
启用 EntraID 支持：
- 在您的 Azure Redis 服务器上启用 Entra ID 身份验证。这可能需要几分钟。
- 将 useEntraID 设置为 "true" 以实现 Azure Cache for Redis 的 EntraID 支持。
将 enableTLS 设置为 "true" 以支持 TLS。

注意：useEntraID 假定您的 UserPrincipal（通过 AzureCLICredential）或系统分配的托管标识具有 RedisDataOwner 角色权限。如果使用用户分配的标识，您需要指定 azureClientID 属性。

GCP Cloud MemoryStore

注意

Dapr CLI 在自托管模式下作为 dapr init 命令的一部分自动部署本地 redis 实例。

Redis Sentinel 配置

使用 Redis Sentinel 实现高可用性时，将 redisType 设置为 "node"，使用 failover: "true" 启用故障转移模式，并提供 sentinel 主节点名称。可以在 redisHost 字段中以逗号分隔的列表形式指定多个 sentinel 地址以实现冗余。

```yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: redis-pubsub
spec:
  type: pubsub.redis
  version: v1
  metadata:
  - name: redisHost
    value: "sentinel1:26379,sentinel2:26379,sentinel3:26379"
  - name: redisType
    value: "node"
  - name: failover
    value: "true"
  - name: sentinelMasterName
    value: "mymaster"
  ```

40 - RethinkDB 绑定规范

RethinkDB 绑定组件的详细文档

组件格式

RethinkDB 状态存储支持事务，这意味着它可用于支持 Dapr actors。Dapr 仅持久化 actor 的当前状态，不允许用户跟踪 actor 状态随时间如何变化。

为了使用户能够跟踪 actor 状态的变化，此绑定利用 RethinkDB 的内置能力来监控 RethinkDB 表以及在变化时同时包含 old 和 new 状态的事件。此绑定在 Dapr 状态表上创建一个订阅，并使用 Dapr 输入绑定接口流式传输这些变化。

要设置 RethinkDB 状态变更绑定，请创建类型为 bindings.rethinkdb.statechange 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: changes
spec:
  type: bindings.rethinkdb.statechange
  version: v1
  metadata:
  - name: address
    value: "<REPLACE-RETHINKDB-ADDRESS>" # 必填，例如 127.0.0.1:28015 或 rethinkdb.default.svc.cluster.local:28015。
  - name: database
    value: "<REPLACE-RETHINKDB-DB-NAME>" # 必填，例如 dapr（仅限字母数字）
  - name: direction 
    value: "<DIRECTION-OF-RETHINKDB-BINDING>"

规范元数据字段

字段	必填	绑定支持	详细信息	示例
`address`	Y	Input	RethinkDB 服务器地址	`"27.0.0.1:28015"`, `"rethinkdb.default.svc.cluster.local:28015"`
`database`	Y	Input	RethinDB 数据库名称	`"dapr"`
`direction`	N	Input	绑定的方向	`"input"`

绑定支持

此组件仅支持输入绑定接口。

41 - Apache RocketMQ binding 规范

Apache RocketMQ binding 组件的详细文档

组件格式

要设置 Apache RocketMQ binding，请创建一个类型为 bindings.rocketmq 的组件。
有关如何创建和应用 binding 配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.rocketmq
  version: v1
  metadata:
    - name: accessProto
      value: "tcp"
    - name: nameServer
      value: "localhost:9876"
    - name: endpoint
      value: "http://localhost:8080"
    - name: topics
      value: "topic1,topic2"
    - name: consumerGroup
      value: "my-consumer-group"
    # 可选
    - name: consumerBatchSize
      value: "10"
    - name: consumerThreadNums
      value: "4"
    - name: retries
      value: "3"
    - name: instanceId
      value: "my-instance"

警告

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用 secret store 来管理密钥。

规范元数据字段

字段	必填	Binding 支持	详情	示例
`topics`	Y	Input/Output	用于发布或订阅的以逗号分隔的主题列表。	`"topic1,topic2"`
`nameServer`	N	Input/Output	RocketMQ name server 地址。	`"localhost:9876"`
`endpoint`	N	Input/Output	RocketMQ 端点（用于 `http` 协议）。	`"http://localhost:8080"`
`accessProto`	N	Input/Output	用于连接 RocketMQ 的 SDK 协议。	`"tcp"`, `"tcp-cgo"`, `"http"`
`consumerGroup`	N	Input/Output	RocketMQ 订阅者的消费者组名称。	`"my-consumer-group"`
`consumerBatchSize`	N	Input	消费消息的批次大小。	`"10"`
`consumerThreadNums`	N	Input	消费者线程数量（用于 `tcp-cgo` 协议）。	`"4"`
`instanceId`	N	Input/Output	RocketMQ 命名空间实例 ID。	`"my-instance"`
`nameServerDomain`	N	Input/Output	RocketMQ name server 的域名。	`"rocketmq.example.com"`
`retries`	N	Input/Output	连接到 RocketMQ broker 的重试次数。	`"3"`
`accessKey`	N	Input/Output	用于身份验证的访问密钥。如果启用了访问控制，则为必填项。	`"access-key"`
`secretKey`	N	Input/Output	用于身份验证的密钥。如果启用了访问控制，则为必填项。	`"secret-key"`

注意：accessKey 和 secretKey 可以存储在 Dapr secret store 中，而不是存储在 YAML 文件中，以提高安全性。

使用访问密钥进行身份验证

要使用访问密钥身份验证，请在配置中包含以下元数据字段：

- name: accessKey
  secretKeyRef:
    name: rocketmq-secrets
    key: accessKey
- name: secretKey
  secretKeyRef:
    name: rocketmq-secrets
    key: secretKey

这允许从 secret store 安全地获取凭据。

Binding 支持

此组件同时支持输入和输出 binding 接口。

此组件支持以下操作的输出 binding：

create：发布新消息
read：从 RocketMQ 主题消费消息

按请求设置主题

您可以按请求覆盖组件元数据中的主题：

{
  "operation": "create",
  "metadata": {
    "topics": "dynamicTopic"
  },
  "data": "This is a test message for RocketMQ!"
}

重试行为

使用 retries 元数据字段指定 Dapr 在失败前应尝试连接 RocketMQ 的次数：

- name: retries
  value: "5"

42 - SFTP binding spec

Secure File Transfer Protocol (SFTP) binding 组件的详细文档

组件格式

要设置 SFTP binding，请创建一个类型为 bindings.sftp 的组件。请参阅本指南了解如何创建和应用 binding 配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.sftp
  version: v1
  metadata:
  - name: rootPath
    value: "<string>"
  - name: address
    value: "<string>"
  - name: username
    value: "<string>"
  - name: password
    value: "*****************"
  - name: privateKey
    value: "*****************"
  - name: privateKeyPassphrase
    value: "*****************"
  - name: hostPublicKey
    value: "*****************"
  - name: knownHostsFile
    value: "<string>"
  - name: insecureIgnoreHostKey
    value: "<bool>"
  - name: sequentialMode
    value: "<bool>"

规范元数据字段

Field	Required	Binding support	Details	Example
`rootPath`	Y	Output	默认工作目录的根路径	`"/path"`
`address`	Y	Output	SFTP 服务器地址	`"localhost:22"`
`username`	Y	Output	用于认证的用户名	`"username"`
`password`	N	Output	用于用户名/密码认证的密码	`"password"`
`privateKey`	N	Output	用于公钥认证的私钥	"\|- —–BEGIN OPENSSH PRIVATE KEY—– ***************** —–END OPENSSH PRIVATE KEY—–"
`privateKeyPassphrase`	N	Output	用于公钥认证的私钥密码	`"passphrase"`
`hostPublicKey`	N	Output	用于主机验证的主机公钥	`"ecdsa-sha2-nistp256 *** root@openssh-server"`
`knownHostsFile`	N	Output	用于主机验证的已知主机文件	`"/path/file"`
`insecureIgnoreHostKey`	N	Output	允许跳过主机验证。默认为 `"false"`	`"true"`, `"false"`
`sequentialMode`	N	Output	用于指定单个 SFTP 连接内是否允许多个并发操作。将此设置为 true 可以防止可能干扰严格 SFTP 服务器的并发操作。默认为 `"false"`	`"true"`, `"false"`

Binding 支持

此组件支持输出 binding，包含以下操作：

create：创建文件
get：获取文件
list：列出文件
delete：删除文件

创建文件

要执行创建文件操作，请使用 POST 方法调用 SFTP binding，并附带以下 JSON 请求体：

{
  "operation": "create",
  "data": "<YOUR_BASE_64_CONTENT>",
  "metadata": {
    "fileName": "<filename>",
  }
}

示例

curl -d "{ \"operation\": \"create\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"fileName\": \"my-test-file.jpg\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "YOUR_BASE_64_CONTENT", "metadata": { "fileName": "my-test-file.jpg" } }' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含以下 JSON：

{
   "fileName": "<filename>"
}

获取文件

要执行获取文件操作，请使用 POST 方法调用 SFTP binding，并附带以下 JSON 请求体：

{
  "operation": "get",
  "metadata": {
    "fileName": "<filename>"
  }
}

示例

curl -d '{ \"operation\": \"get\", \"metadata\": { \"fileName\": \"filename\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "get", "metadata": { "fileName": "filename" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应体包含文件中存储的值。

列出文件

要执行列出文件操作，请使用 POST 方法调用 SFTP binding，并附带以下 JSON 请求体：

{
  "operation": "list"
}

如果您只想列出 rootPath 下某个特定目录中的文件，请在元数据中将相对目录名称指定为 fileName。

{
  "operation": "list",
  "metadata": {
    "fileName": "my/cool/directory"
  }
}

示例

curl -d '{ \"operation\": \"list\", \"metadata\": { \"fileName\": \"my/cool/directory\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "list", "metadata": { "fileName": "my/cool/directory" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

响应是一个文件名的 JSON 数组。

删除文件

要执行删除文件操作，请使用 POST 方法调用 SFTP binding，并附带以下 JSON 请求体：

{
  "operation": "delete",
  "metadata": {
    "fileName": "myfile"
  }
}

示例

curl -d '{ \"operation\": \"delete\", \"metadata\": { \"fileName\": \"myfile\" }}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "delete", "metadata": { "fileName": "myfile" }}' \
      http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应

如果成功，返回 HTTP 204（No Content）和空响应体。

43 - SMTP 绑接规范

SMTP 绑接组件的详细文档

组件格式

要设置 SMTP 绑接，请创建类型为 bindings.smtp 的组件。有关如何创建和应用绑接配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: smtp
spec:
  type: bindings.smtp
  version: v1
  metadata:
  - name: host
    value: "smtp host"
  - name: port
    value: "smtp port"
  - name: user
    value: "username"
  - name: password
    value: "password"
  - name: skipTLSVerify
    value: true|false
  - name: emailFrom
    value: "sender@example.com"
  - name: emailTo
    value: "receiver@example.com"
  - name: emailCC
    value: "cc@example.com"
  - name: emailBCC
    value: "bcc@example.com"
  - name: subject
    value: "subject"
  - name: priority
    value: "[value 1-5]"

警告

上述示例配置中包含以纯文本形式呈现的用户名和密码。建议按照此处的说明使用 secret store 来管理密钥。

规范元数据字段

字段	必填	绑接支持	详情	示例
`host`	Y	Output	SMTP 服务器运行的主机地址	`"smtphost"`
`port`	Y	Output	SMTP 服务器监听的端口	`"9999"`
`user`	Y	Output	用于 SMTP 服务器身份验证的用户名	`"user"`
`password`	Y	Output	用户的密码	`"password"`
`skipTLSVerify`	N	Output	如果设置为 true，将不会验证 SMTP 服务器的 TLS 证书。默认值为 `"false"`	`"true"`, `"false"`
`emailFrom`	N	Output	如果设置，指定发件人的电子邮件地址。参见此处	`"me@example.com"`
`emailTo`	N	Output	如果设置，指定收件人的电子邮件地址。参见此处	`"me@example.com"`
`emailCc`	N	Output	如果设置，指定抄送的电子邮件地址。参见此处	`"me@example.com"`
`emailBcc`	N	Output	如果设置，指定密送的电子邮件地址。参见此处	`"me@example.com"`
`subject`	N	Output	如果设置，指定电子邮件的主题。参见此处	`"邮件主题"`
`priority`	N	Output	如果设置，指定电子邮件的优先级（X-Priority），从 1（最低）到 5（最高）（默认值：3）。参见此处	`"1"`

绑接支持

该组件支持输出绑接，具有以下操作：

create

示例请求

您可以在每个请求中指定以下可选元数据属性：

emailFrom
emailTo
emailCC
emailBCC
subject
priority

发送电子邮件时，配置和请求中的元数据会被合并。合并后的元数据集必须至少包含 emailFrom、emailTo 和 subject 字段。

emailTo、emailCC 和 emailBCC 字段可以包含多个以分号分隔的电子邮件地址。

示例：

{
  "operation": "create",
  "metadata": {
    "emailTo": "dapr-smtp-binding@example.net",
    "emailCC": "cc1@example.net; cc2@example.net",
    "subject": "电子邮件主题",
    "priority": "1"
  },
  "data": "测试 Dapr SMTP 绑接"
}

emailTo、emailCC 和 emailBCC 字段可以包含多个以分号分隔的电子邮件地址。

44 - Twilio SendGrid binding spec

Twilio SendGrid 绑定组件的详细文档

组件格式

要设置 Twilio SendGrid 绑定，需创建一个类型为 bindings.twilio.sendgrid 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: sendgrid
spec:
  type: bindings.twilio.sendgrid
  version: v1
  metadata:
  - name: emailFrom
    value: "testapp@dapr.io" # optional
  - name: emailFromName
    value: "test app" # optional
  - name: emailTo
    value: "dave@dapr.io" # optional
  - name: emailToName
    value: "dave" # optional
  - name: subject
    value: "Hello!" # optional
  - name: emailCc
    value: "jill@dapr.io" # optional
  - name: emailBcc
    value: "bob@dapr.io" # optional
  - name: dynamicTemplateId
    value: "d-123456789" # optional
  - name: dynamicTemplateData
    value: '{"customer":{"name":"John Smith"}}' # optional
  - name: apiKey
    value: "YOUR_API_KEY" # required, this is your SendGrid key

Warning

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体说明请参见此处。

规范元数据字段

字段	必填	绑定支持	详情	示例
`apiKey`	Y	Output	SendGrid API 密钥，应将其视为机密值	`"apikey"`
`emailFrom`	N	Output	如果设置，则指定电子邮件的"发件人"邮箱地址。仅允许单个邮箱地址。可选字段，参见下文	`"me@example.com"`
`emailFromName`	N	Output	如果设置，则指定电子邮件的"发件人"名称。可选字段，参见下文	`"me"`
`emailTo`	N	Output	如果设置，则指定电子邮件的"收件人"邮箱地址。仅允许单个邮箱地址。可选字段，参见下文	`"me@example.com"`
`emailToName`	N	Output	如果设置，则指定电子邮件的"收件人"名称。可选字段，参见下文	`"me"`
`emailCc`	N	Output	如果设置，则指定电子邮件的"抄送"邮箱地址。仅允许单个邮箱地址。可选字段，参见下文	`"me@example.com"`
`emailBcc`	N	Output	如果设置，则指定电子邮件的"密送"邮箱地址。仅允许单个邮箱地址。可选字段，参见下文	`"me@example.com"`
`subject`	N	Output	如果设置，则指定电子邮件的主题。可选字段，参见下文	`"subject of the email"`

绑定支持

该组件支持输出绑定，包含以下操作：

create

示例请求载荷

您也可以在输出绑定请求中指定任何可选的元数据属性（例如 emailFrom、emailTo、subject 等）。

{
  "operation": "create",
  "metadata": {
    "emailTo": "changeme@example.net",
    "subject": "An email from Dapr SendGrid binding"
  },
  "data": "<h1>Testing Dapr Bindings</h1>This is a test.<br>Bye!"
}

动态模板

如果使用动态模板，需要提供 dynamicTemplateId，然后使用 dynamicTemplateData：

{
  "operation": "create",
  "metadata": {
    "emailTo": "changeme@example.net",
    "subject": "An template email from Dapr SendGrid binding",
    "dynamicTemplateId": "d-123456789",
    "dynamicTemplateData": "{\"customer\":{\"name\":\"John Smith\"}}"
  }
}

45 - Twilio SMS 绑定规范

Twilio SMS 绑定组件的详细文档

组件格式

要设置 Twilio SMS 绑定，请创建一个类型为 bindings.twilio.sms 的组件。有关如何创建和应用绑定配置，请参阅本指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.twilio.sms
  version: v1
  metadata:
  - name: toNumber # required.
    value: "111-111-1111"
  - name: fromNumber # required.
    value: "222-222-2222"
  - name: accountSid # required.
    value: "*****************"
  - name: authToken # required.
    value: "*****************"

Warning

上述示例将密钥作为纯字符串使用。建议按照此处的描述使用 secret store 来存储密钥。

规范元数据字段

字段	必填	绑定支持	详情	示例
`toNumber`	Y	Output	接收短信的目标号码	`"111-111-1111"`
`fromNumber`	Y	Output	发送方电话号码	`"222-222-2222"`
`accountSid`	Y	Output	Twilio 账户 SID	`"account sid"`
`authToken`	Y	Output	Twilio 认证令牌	`"auth token"`

绑定支持

该组件支持以下操作的输出绑定：

create

46 - Wasm

WebAssembly 绑定组件的详细文档

概述

借助 WebAssembly，你可以安全地运行以其他语言编译的代码。运行时执行 WebAssembly 模块（Wasm），它们通常是带有 .wasm 扩展名的二进制文件。

Wasm 绑定允许你通过向其传递命令行参数或环境变量来调用编译为 Wasm 的程序，就像使用普通子进程一样。例如，即使 Dapr 是用 Go 编写的，并且运行在未安装 Python 的平台上，你也可以使用 Python 来满足调用请求！

Wasm 二进制文件必须是使用 WebAssembly 系统接口（WASI）编译的程序。该二进制文件可以是你编写的程序（例如 Go），或者是你用于运行内联脚本的解释器（例如 Python）。

你至少需要指定一个使用规范 WASI 版本 wasi_snapshot_preview1（也称为 wasip1）编译的 Wasm 二进制文件，通常简称为 wasi。

注意： 如果使用 Go 1.21+ 编译，这是 GOOS=wasip1 GOARCH=wasm。在 TinyGo、Rust 和 Zig 中，这是目标 wasm32-wasi。

你也可以重用现有的二进制文件。例如，Wasm Language Runtimes 分发了已编译为 WASI 的解释器（包括 PHP、Python 和 Ruby）。

Wasm 二进制文件从 URL 加载。例如，URL file://rewrite.wasm 从进程的当前目录加载 rewrite.wasm。在 Kubernetes 上，请参阅如何：将 Pod 卷挂载到 Dapr 边车以配置可以包含 Wasm 二进制文件的文件系统挂载。也可以从远程 URL 获取 Wasm 二进制文件。在这种情况下，URL 必须精确指向一个 Wasm 二进制文件。例如：

http://example.com/rewrite.wasm，或
https://example.com/rewrite.wasm。

Dapr 使用 wazero 来运行这些二进制文件，因为它没有依赖项。这使得除了 Dapr 本身之外，无需安装任何东西即可使用 WebAssembly。

Wasm 输出绑定支持使用 wasi-http 规范进行 HTTP 客户端调用。你可以在以下位置找到多种语言进行 HTTP 调用的示例代码：

注意

如果你只是想进行 HTTP 调用，使用服务调用 API会更简单。但是，如果你需要添加自己的逻辑——例如，过滤或调用多个 API 端点——请考虑使用 Wasm。

组件格式

要配置 Wasm 绑定，请创建类型为 bindings.wasm 的组件。请参阅本指南了解如何创建和应用绑定配置。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: wasm
spec:
  type: bindings.wasm
  version: v1
  metadata:
    - name: url
      value: "file://uppercase.wasm"

规范元数据字段

字段	详情	必填	示例
`url`	包含要实例化的 Wasm 二进制文件的资源 URL。支持的协议包括 `file://`、`http://` 和 `https://`。`file://` URL 的路径相对于 Dapr 进程，除非它以 `/` 开头。	true	`file://hello.wasm`, `https://example.com/hello.wasm`

绑定支持

此组件支持 输出绑定，具有以下操作：

execute

示例请求

data 字段（如果存在）将是程序的 STDIN。你可以选择在每个请求中传递元数据属性：

args 任何 CLI 参数，以逗号分隔。这不包括程序名称。

例如，考虑将 url 绑定到 Ruby 解释器，例如来自 webassembly-language-runtimes：

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: wasm
spec:
  type: bindings.wasm
  version: v1
  metadata:
  - name: url
    value: "https://github.com/vmware-labs/webassembly-language-runtimes/releases/download/ruby%2F3.2.0%2B20230215-1349da9/ruby-3.2.0-slim.wasm"

假设你想在端口 3500 上启动 Dapr 并使用 Wasm 绑定，你可以运行：

$ dapr run --app-id wasm --dapr-http-port 3500 --resources-path components

以下请求返回 Hello "salaboy"：

$ curl -X POST http://localhost:3500/v1.0/bindings/wasm -d'
{
  "operation": "execute",
  "metadata": {
    "args": "-ne,print \"Hello \"; print"
  },
  "data": "salaboy"
}'

47 - Zeebe command binding 规范

Zeebe command binding 组件的详细文档

组件格式

要设置 Zeebe command binding，请创建类型为 bindings.zeebe.command 的组件。请参阅此指南了解如何创建和应用 binding 配置。

请参阅此处获取 Zeebe 文档。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.zeebe.command
  version: v1
  metadata:
  - name: gatewayAddr
    value: "<host>:<port>"
  - name: gatewayKeepAlive
    value: "45s"
  - name: usePlainTextConnection
    value: "true"
  - name: caCertificatePath
    value: "/path/to/ca-cert"

规范元数据字段

字段	必填	Binding 支持	详情	示例
`gatewayAddr`	Y	输出	Zeebe gateway 地址	`"localhost:26500"`
`gatewayKeepAlive`	N	输出	设置向 gateway 发送保活消息的频率。默认为 45 秒	`"45s"`
`usePlainTextConnection`	N	输出	是否使用纯文本连接	`"true"`, `"false"`
`caCertificatePath`	N	输出	CA 证书的路径	`"/path/to/ca-cert"`

Binding 支持

此组件支持输出 binding，包含以下操作：

topology
deploy-process
deploy-resource
create-instance
cancel-instance
set-variables
resolve-incident
publish-message
activate-jobs
complete-job
fail-job
update-job-retries
throw-error

输出 binding

Zeebe 在底层使用了 gRPC，作为我们在此 binding 中使用的 Zeebe 客户端的基础。请参阅 gRPC API 参考以获取更多信息。

topology

topology 操作获取 gateway 所属集群的当前拓扑结构。

要执行 topology 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {},
  "operation": "topology"
}

响应

binding 返回以下 JSON 响应：

{
  "brokers": [
    {
      "nodeId": null,
      "host": "172.18.0.5",
      "port": 26501,
      "partitions": [
        {
          "partitionId": 1,
          "role": null,
          "health": null
        }
      ],
      "version": "0.26.0"
    }
  ],
  "clusterSize": 1,
  "partitionsCount": 1,
  "replicationFactor": 1,
  "gatewayVersion": "0.26.0"
}

响应值为：

brokers - 此集群中的 broker 列表
- nodeId - broker 的唯一（在集群内）节点 ID
- host - broker 的主机名
- port - broker 的端口
- port - broker 的端口
- partitions - 在此 broker 上管理或复制的分区列表
  - partitionId - 此分区的唯一 ID
  - role - broker 在此分区中的角色
  - health - 此分区的健康状态
- version - broker 版本
clusterSize - 集群中有多少节点
partitionsCount - 集群中分布了多少分区
replicationFactor - 此集群配置的复制因子
gatewayVersion - gateway 版本

deploy-process

‘deploy-resource’ 的已弃用别名。

deploy-resource

deploy-resource 操作向 Zeebe 部署单个资源。资源可以是流程（BPMN）或决策和决策需求（DMN）。

要执行 deploy-resource 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": "YOUR_FILE_CONTENT",
  "metadata": {
    "fileName": "products-process.bpmn"
  },
  "operation": "deploy-resource"
}

元数据参数为：

fileName - 资源文件的名称

响应

binding 返回以下 JSON 响应：

{
  "key": 2251799813685252,
  "deployments": [
    {
      "Metadata": {
        "Process": {
          "bpmnProcessId": "products-process",
          "version": 2,
          "processDefinitionKey": 2251799813685251,
          "resourceName": "products-process.bpmn"
        }
      }
    }
  ]
}

{
  "key": 2251799813685253,
  "deployments": [
    {
      "Metadata": {
        "Decision": {
          "dmnDecisionId": "products-approval",
          "dmnDecisionName": "Products approval",
          "version": 1,
          "decisionKey": 2251799813685252,
          "dmnDecisionRequirementsId": "Definitions_0c98xne",
          "decisionRequirementsKey": 2251799813685251
        }
      }
    },
    {
      "Metadata": {
        "DecisionRequirements": {
          "dmnDecisionRequirementsId": "Definitions_0c98xne",
          "dmnDecisionRequirementsName": "DRD",
          "version": 1,
          "decisionRequirementsKey": 2251799813685251,
          "resourceName": "products-approval.dmn"
        }
      }
    }
  ]
}

响应值为：

key - 标识部署的唯一键
deployments - 已部署资源的列表，例如流程
- metadata - 部署元数据，每个部署只有一个元数据
  - process- 已部署流程的元数据
    - bpmnProcessId - bpmn 流程 ID，在部署期间解析；与版本一起形成特定流程定义的唯一标识符
    - version - 分配的流程版本
    - processDefinitionKey - 分配的键，作为此流程的唯一标识符
    - resourceName - 解析此流程所用的资源名称
  - decision - 已部署决策的元数据
    - dmnDecisionId - dmn 决策 ID，在部署期间解析；与版本一起形成特定决策的唯一标识符
    - dmnDecisionName - 决策的 dmn 名称，在部署期间解析
    - version - 分配的决策版本
    - decisionKey - 分配的决策键，作为此决策的唯一标识符
    - dmnDecisionRequirementsId - 此决策所属的决策需求图的 dmn ID，在部署期间解析
    - decisionRequirementsKey - 此决策所属的决策需求图的分配键
  - decisionRequirements - 已部署决策需求的元数据
    - dmnDecisionRequirementsId - dmn 决策需求 ID，在部署期间解析；与版本一起形成特定决策的唯一标识符
    - dmnDecisionRequirementsName - 决策需求的 dmn 名称，在部署期间解析
    - version - 分配的决策需求版本
    - decisionRequirementsKey - 分配的决策需求键，作为此决策需求的唯一标识符
    - resourceName - 解析此决策需求所用的资源名称

create-instance

create-instance 操作创建并启动指定流程的实例。用于创建实例的流程定义可以使用其唯一键（由 deploy-process 操作返回）指定，也可以使用 BPMN 流程 ID 和版本指定。

请注意，只有具有无启动事件的流程才能通过此命令启动。

通常，流程创建和执行是解耦的。这意味着该命令创建一个新的流程实例，并立即返回流程实例 ID 作为响应。流程的执行在发送响应之后进行。然而，有些用例需要在流程执行完成时收集其结果。通过定义 withResult 属性，该命令可以"同步"执行流程并通过一组变量接收结果。响应在流程执行完成时发送。

有关更多信息，请访问官方文档。

要执行 create-instance 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "bpmnProcessId": "products-process",
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "create-instance"
}

{
  "data": {
    "processDefinitionKey": 2251799813685895,
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "create-instance"
}

{
  "data": {
    "bpmnProcessId": "products-process",
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    },
    "withResult": true,
    "requestTimeout": "30s",
    "fetchVariables": ["productId"]
  },
  "operation": "create-instance"
}

数据参数为：

bpmnProcessId - 要实例化的流程定义的 BPMN 流程 ID
processDefinitionKey - 标识要实例化的流程定义的唯一键
version - （可选，默认：最新版本）要实例化的流程的版本
variables - （可选）JSON 文档，将为流程实例的根变量作用域实例化变量；它必须是 JSON 对象，因为变量将以键值方式映射。例如，{ “a”: 1, “b”: 2 } 将创建两个变量，分别命名为 “a” 和 “b”，并具有其关联值。[{ “a”: 1, “b”: 2 }] 将不是有效参数，因为 JSON 文档的根是数组而不是对象
withResult - （可选，默认：false）如果设置为 true，流程将被同步实例化和执行
requestTimeout - （可选，仅在 withResult=true 时使用）超时时间，如果流程在 requestTimeout 之前未完成，请求将被关闭。如果 requestTimeout = 0，则使用 gateway 中配置的通用 requestTimeout
fetchVariables - （可选，仅在 withResult=true 时使用）要包含在响应的 variables 属性中的变量名称列表。如果为空，将返回根作用域中的所有可见变量

响应

binding 返回以下 JSON 响应：

{
  "processDefinitionKey": 2251799813685895,
  "bpmnProcessId": "products-process",
  "version": 3,
  "processInstanceKey": 2251799813687851,
  "variables": "{\"productId\":\"some-product-id\"}"
}

响应值为：

processDefinitionKey - 用于创建流程实例的流程定义的键
bpmnProcessId - 用于创建流程实例的流程定义的 BPMN 流程 ID
version - 用于创建流程实例的流程定义的版本
processInstanceKey - 创建的流程实例的唯一标识符
variables - （可选，仅在请求中使用了 withResult=true）由根作用域中的可见变量组成的 JSON 文档；作为序列化的 JSON 文档返回

cancel-instance

cancel-instance 操作取消正在运行的流程实例。

要执行 cancel-instance 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "processInstanceKey": 2251799813687851
  },
  "operation": "cancel-instance"
}

数据参数为：

processInstanceKey - 流程实例键

响应

binding 不返回响应正文。

set-variables

set-variables 操作为元素实例（例如流程实例、流元素实例）创建或更新变量。

要执行 set-variables 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "elementInstanceKey": 2251799813687880,
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "set-variables"
}

数据参数为：

elementInstanceKey - 特定元素的唯一标识符；可以是流程实例键（在实例创建时获得），也可以是给定元素，例如服务任务（请参阅 job 消息上的 elementInstanceKey）
local - （可选，默认：false）如果为 true，变量将严格合并到本地作用域（由 elementInstanceKey 指示）；这意味着变量不会传播到上层作用域。例如，假设我们有两个作用域 ‘1’ 和 ‘2’，每个都有有效变量：1 => { "foo" : 2 }，2 => { "bar" : 1 }。如果我们发送更新请求，elementInstanceKey = 2，variables { "foo" : 5 }，并且 local 为 true，那么作用域 1 将保持不变，作用域 2 现在将是 { "bar" : 1, "foo" 5 }。但是如果 local 为 false，那么作用域 1 将是 { "foo": 5 }，作用域 2 将是 { "bar" : 1 }
variables - JSON 序列化文档，将变量描述为键值对；文档的根必须是对象

响应

binding 返回以下 JSON 响应：

{
  "key": 2251799813687896
}

响应值为：

key - set variables 命令的唯一键

resolve-incident

resolve-incident 操作解决事件。

要执行 resolve-incident 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "incidentKey": 2251799813686123
  },
  "operation": "resolve-incident"
}

数据参数为：

incidentKey - 要解决的事件的唯一 ID

响应

binding 不返回响应正文。

publish-message

publish-message 操作发布单个消息。消息将发布到从其关联键计算出的特定分区。

要执行 publish-message 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "messageName": "product-message",
    "correlationKey": "2",
    "timeToLive": "1m",
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    },
  },  
  "operation": "publish-message"
}

数据参数为：

messageName - 消息的名称
correlationKey - （可选）消息的关联键
timeToLive - （可选）消息应在 broker 上缓冲多长时间
messageId - （可选）消息的唯一 ID；可以省略。仅用于确保只有一条具有给定 ID 的消息会被发布（在其生命周期内）
variables - （可选）消息变量作为 JSON 文档；要有效，文档的根必须是对象，例如 { “a”: “foo” }。[ “foo” ] 将无效

响应

binding 返回以下 JSON 响应：

{
  "key": 2251799813688225
}

响应值为：

key - 已发布的消息的唯一 ID

activate-jobs

activate-jobs 操作以轮询方式遍历所有已知分区，激活达到所请求最大数量的作业，并在激活时将其流式传输回客户端。

要执行 activate-jobs 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "jobType": "fetch-products",
    "maxJobsToActivate": 5,
    "timeout": "5m",
    "workerName": "products-worker",
    "fetchVariables": [
      "productId",
      "productName",
      "productKey"
    ],
    "requestTimeout": "30s"
  },
  "operation": "activate-jobs"
}

数据参数为：

jobType - 作业类型，在 BPMN 流程中定义（例如 <zeebe:taskDefinition type="fetch-products" />）
maxJobsToActivate - 此请求要激活的最大作业数
timeout - （可选，默认：5 分钟）在此调用后返回的作业在超时之前不会被另一调用激活
workerName - （可选，默认：default）激活作业的工作程序名称，主要用于日志记录目的
fetchVariables - （可选）要作为作业变量获取的变量列表；如果为空，将返回激活时作业作用域的所有可见变量
requestTimeout - （可选）请求将在至少激活一个作业时或 requestTimeout 之后完成。如果 requestTimeout = 0，则使用默认超时。如果 requestTimeout < 0，则禁用长轮询，请求立即完成，即使没有激活作业

响应

binding 返回以下 JSON 响应：

[
  {
    "key": 2251799813685267,
    "type": "fetch-products",
    "processInstanceKey": 2251799813685260,
    "bpmnProcessId": "products",
    "processDefinitionVersion": 1,
    "processDefinitionKey": 2251799813685249,
    "elementId": "Activity_test",
    "elementInstanceKey": 2251799813685266,
    "customHeaders": "{\"process-header-1\":\"1\",\"process-header-2\":\"2\"}",
    "worker": "test", 
    "retries": 1,
    "deadline": 1694091934039,
    "variables":"{\"productId\":\"some-product-id\"}"
  }
]

响应值为：

key - 键，作业的唯一标识符
type - 作业类型（应与请求的类型匹配）
processInstanceKey - 作业的流程实例键
bpmnProcessId - 作业流程定义的 bpmn 流程 ID
processDefinitionVersion - 作业流程定义的版本
processDefinitionKey - 作业流程定义的键
elementId - 关联的任务元素 ID
elementInstanceKey - 标识关联任务的唯一键，在流程实例作用域内唯一
customHeaders - 在建模期间定义的一组自定义标头；作为序列化的 JSON 文档返回
worker - 激活此作业的工作程序的名称
retries - 此作业剩余的重试次数（应始终为正数）
deadline - 作业可以再次激活的时间，作为 UNIX epoch 时间戳发送
variables - 在激活时计算，由任务作用域的所有可见变量组成；作为序列化的 JSON 文档返回

complete-job

complete-job 操作使用给定的负载完成作业，从而允许完成关联的服务任务。

要执行 complete-job 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "jobKey": 2251799813686172,
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "complete-job"
}

数据参数为：

jobKey - 唯一作业标识符，从 activate jobs 响应中获得
variables - （可选）表示当前任务作用域中变量的 JSON 文档

响应

binding 不返回响应正文。

fail-job

fail-job 操作将作业标记为失败；如果 retries 参数为正数，则作业将可以立即再次激活，工作程序可以再次尝试处理它。但是如果为零或负数，将引发事件，使用给定的 errorMessage 进行标记，并且在事件解决之前作业将无法激活。

要执行 fail-job 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "jobKey": 2251799813685739,
    "retries": 5,
    "errorMessage": "some error occurred",
    "retryBackOff": "30s",
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "fail-job"
}

数据参数为：

jobKey - 唯一作业标识符，在激活作业时获得
retries - 作业应剩余的重试次数
errorMessage - （可选）描述作业失败原因的消息；如果作业耗尽重试次数并引发事件，这特别有用，因为此消息可以帮助解释引发事件的原因
retryBackOff - （可选）下次重试的退避超时
variables - （可选）JSON 文档，将在作业关联的任务的本地作用域实例化变量；它必须是 JSON 对象，因为变量将以键值方式映射。例如，{ “a”: 1, “b”: 2 } 将创建两个变量，分别命名为 “a” 和 “b”，并具有其关联值。[{ “a”: 1, “b”: 2 }] 将不是有效参数，因为 JSON 文档的根是数组而不是对象

响应

binding 不返回响应正文。

update-job-retries

update-job-retries 操作更新作业的剩余重试次数。这对于已用尽重试次数的作业最有用，前提是根本问题已解决。

要执行 update-job-retries 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "jobKey": 2251799813686172,
    "retries": 10
  },
  "operation": "update-job-retries"
}

数据参数为：

jobKey - 唯一作业标识符，通过 activate-jobs 操作获得
retries - 作业的新重试次数；必须为正数

响应

binding 不返回响应正文。

throw-error

throw-error 操作抛出错误以指示在处理作业时发生了业务错误。错误由错误代码标识，并由流程中具有相同错误代码的错误捕获事件处理。

要执行 throw-error 操作，请使用 POST 方法调用 Zeebe command binding，并使用以下 JSON 请求体：

{
  "data": {
    "jobKey": 2251799813686172,
    "errorCode": "product-fetch-error",
    "errorMessage": "The product could not be fetched",
    "variables": {
      "productId": "some-product-id",
      "productName": "some-product-name",
      "productKey": "some-product-key"
    }
  },
  "operation": "throw-error"
}

数据参数为：

jobKey - 唯一作业标识符，在激活作业时获得
errorCode - 将与错误捕获事件匹配的错误代码
errorMessage - （可选）提供其他上下文的错误消息
variables - （可选）JSON 文档，将在作业关联的任务的本地作用域实例化变量；它必须是 JSON 对象，因为变量将以键值方式映射。例如，{ “a”: 1, “b”: 2 } 将创建两个变量，分别命名为 “a” 和 “b”，并具有其关联值。[{ “a”: 1, “b”: 2 }] 将不是有效参数，因为 JSON 文档的根是数组而不是对象

响应

binding 不返回响应正文。

48 - Zeebe JobWorker 绑定规范

Zeebe JobWorker 绑定组件的详细文档

组件格式

要设置 Zeebe JobWorker 绑定，需创建一个类型为 bindings.zeebe.jobworker 的组件。请参阅此指南了解如何创建和应用绑定配置。

有关 Zeebe JobWorker 的文档，请参阅此文档。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: <NAME>
spec:
  type: bindings.zeebe.jobworker
  version: v1
  metadata:
  - name: gatewayAddr
    value: "<host>:<port>"
  - name: gatewayKeepAlive
    value: "45s"
  - name: usePlainTextConnection
    value: "true"
  - name: caCertificatePath
    value: "/path/to/ca-cert"
  - name: workerName
    value: "products-worker"
  - name: workerTimeout
    value: "5m"
  - name: requestTimeout
    value: "15s"
  - name: jobType
    value: "fetch-products"
  - name: maxJobsActive
    value: "32"
  - name: concurrency
    value: "4"
  - name: pollInterval
    value: "100ms"
  - name: pollThreshold
    value: "0.3"
  - name: fetchVariables
    value: "productId, productName, productKey"
  - name: autocomplete
    value: "true"
  - name: retryBackOff
    value: "30s"
  - name: direction
    value: "input"

规范元数据字段

字段	必填	绑定支持	详情	示例
`gatewayAddr`	Y	Input	Zeebe 网关地址	`"localhost:26500"`
`gatewayKeepAlive`	N	Input	设置向网关发送保活消息的频率。默认为 45 秒	`"45s"`
`usePlainTextConnection`	N	Input	是否使用纯文本连接	`"true"`, `"false"`
`caCertificatePath`	N	Input	CA 证书的路径	`"/path/to/ca-cert"`
`workerName`	N	Input	激活任务的 worker 名称，主要用于日志记录目的	`"products-worker"`
`workerTimeout`	N	Input	在此调用后返回的任务在超时到达前不会被另一个调用激活；默认为 5 分钟	`"5m"`
`requestTimeout`	N	Input	当至少有一个任务被激活或在 requestTimeout 之后，请求将完成。如果 requestTimeout = 0，则使用默认超时。如果 requestTimeout < 0，则禁用长轮询，即使没有任务被激活，请求也会立即完成。默认为 10 秒	`"30s"`
`jobType`	Y	Input	任务类型，在 BPMN 流程中定义（例如 `<zeebe:taskDefinition type="fetch-products" />`)	`"fetch-products"`
`maxJobsActive`	N	Input	设置此 worker 同时激活的最大任务数量。默认为 32	`"32"`
`concurrency`	N	Input	完成任务的最大并发 spawned goroutine 数量。默认为 4	`"4"`
`pollInterval`	N	Input	设置轮询新任务的最大间隔。默认为 100 毫秒	`"100ms"`
`pollThreshold`	N	Input	设置轮询新任务前缓冲激活任务的阈值，即 threshold * maxJobsActive。默认为 0.3	`"0.3"`
`fetchVariables`	N	Input	要获取作为任务变量的变量列表；如果为空，则将返回激活时任务范围内所有可见的变量	`"productId"`, `"productName"`, `"productKey"`
`autocomplete`	N	Input	指示任务是否应自动完成。如果未设置，默认情况下所有任务都将自动完成。如果 worker 应通过业务错误或事件手动完成或使任务失败，则禁用它	`"true"`, `"false"`
`retryBackOff`	N	Input	任务失败时下次重试的退避超时时间	`15s`
`direction`	N	Input	绑定的方向	`"input"`

绑定支持

此组件支持输入绑定接口。

输入绑定

变量

Zeebe 流程引擎将流程状态以及流程变量作为可传递的内容处理，这些变量可以在流程实例化时传递，也可以在流程执行期间更新或创建。通过在 fetchVariables 元数据字段中将变量名称定义为逗号分隔的列表，这些变量可以传递给已注册的 job worker。然后，流程引擎会将这些变量及其当前值传递给 job worker 实现。

如果绑定注册了三个变量 productId、productName 和 productKey，则 worker 将使用以下 JSON 主体调用：

{
  "productId": "some-product-id",
  "productName": "some-product-name",
  "productKey": "some-product-key"
}

注意：如果不传递 fetchVariables 元数据字段，所有流程变量都将传递给 worker。

标头

Zeebe 流程引擎能够将自定义任务标头传递给 job worker。这些标头可以为每个服务任务定义。任务标头将由绑定作为元数据（HTTP 标头）传递给 job worker。

绑定还将传递以下与任务相关的变量作为元数据。值将作为字符串传递。该表还包含原始数据类型，以便可以将其转换回 worker 使用的编程语言中的等效数据类型。

元数据	数据类型	描述
X-Zeebe-Job-Key	int64	任务的键，是任务的唯一标识符
X-Zeebe-Job-Type	string	任务的类型（应与请求的类型匹配）
X-Zeebe-Process-Instance-Key	int64	任务的流程实例键
X-Zeebe-Bpmn-Process-Id	string	任务流程定义的 bpmn 流程 ID
X-Zeebe-Process-Definition-Version	int32	任务流程定义的版本
X-Zeebe-Process-Definition-Key	int64	任务流程定义的键
X-Zeebe-Element-Id	string	关联的任务元素 ID
X-Zeebe-Element-Instance-Key	int64	识别关联任务的唯一键，在流程实例范围内唯一
X-Zeebe-Worker	string	激活此任务的 worker 名称
X-Zeebe-Retries	int32	此任务剩余的重试次数（应始终为正数）
X-Zeebe-Deadline	int64	任务可以再次激活的时间，作为 UNIX epoch 时间戳发送
X-Zeebe-Autocomplete	bool	在绑定元数据中定义的自动完成状态

49 - 阿里云对象存储服务绑定规范

阿里云对象存储绑定组件的详细文档

组件格式

要设置阿里云对象存储绑定，需创建一个类型为 bindings.alicloud.oss 的组件。有关如何创建和应用 secretstore 配置，请参阅此指南。有关如何检索和使用 Dapr 组件的密钥，请参阅引用密钥指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: alicloudobjectstorage
spec:
  type: bindings.alicloud.oss
  version: v1
  metadata:
  - name: endpoint
    value: "[endpoint]"
  - name: accessKeyID
    value: "[key-id]"
  - name: accessKey
    value: "[access-key]"
  - name: bucket
    value: "[bucket]"

警告

上述示例将密钥作为纯字符串使用。建议使用密钥存储来管理密钥，具体说明请参见此处。

规范元数据字段

字段	必填	绑定支持	详情	示例
`endpoint`	Y	Output	阿里云 OSS 端点。	https://oss-cn-hangzhou.aliyuncs.com
`accessKeyID`	Y	Output	访问密钥 ID 凭据。
`accessKey`	Y	Output	访问密钥凭据。
`bucket`	Y	Output	存储桶的名称。

绑定支持

此组件支持输出绑定，支持以下操作：

create：创建对象

Create object

要执行创建对象操作，请使用 POST 方法调用绑定，并传入以下 JSON 请求体：

{
  "operation": "create",
  "data": "YOUR_CONTENT"
}

注意

默认情况下，会自动生成一个随机 UUID 作为对象键。有关如何为对象设置键，请参阅下面的元数据支持说明。

示例

保存到随机生成的 UUID 文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\" }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World" }' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

保存到指定文件

curl -d "{ \"operation\": \"create\", \"data\": \"Hello World\", \"metadata\": { \"key\": \"my-key\" } }" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -d '{ "operation": "create", "data": "Hello World", "metadata": { "key": "my-key" } }' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

注意

在 Windows CMD 中需要对 " 字符进行转义。

元数据信息

对象键

默认情况下，阿里云 OSS 输出绑定会自动生成一个 UUID 作为对象键。您可以使用以下元数据设置键：

{
    "data": "file content",
    "metadata": {
        "key": "my-key"
    },
    "operation": "create"
}

50 - 阿里云日志服务绑定规范

阿里云日志服务绑定组件的详细文档

组件格式

要设置阿里云 SLS 绑定，请创建类型为 bindings.alicloud.sls 的组件。有关如何创建和应用绑定配置，请参阅此指南。

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: alicloud.sls
spec:
  type: bindings.alicloud.sls
  version: v1
  metadata:
  - name: AccessKeyID
    value: "[accessKey-id]"
  - name: AccessKeySecret
    value: "[accessKey-secret]"
  - name: Endpoint
    value: "[endpoint]"

规范元数据字段

字段	必填	绑定支持	详情
`AccessKeyID`	Y	Output	Access key ID 凭证。
`AccessKeySecret`	Y	Output	Access key 凭证密钥
`Endpoint`	Y	Output	阿里云 SLS 端点。

绑定支持

此组件支持输出绑定，具有以下操作：

create：创建对象

请求格式

要执行日志存储操作，请使用 POST 方法调用绑定并传入以下 JSON 请求体：

{
    "metadata":{
        "project":"your-sls-project-name",
        "logstore":"your-sls-logstore-name",
        "topic":"your-sls-topic-name",
        "source":"your-sls-source"
    },
    "data":{
        "custome-log-filed":"any other log info"
    },
    "operation":"create"
}

注意

注意，“project”、“logstore”、“topic” 和 “source” 属性的值应在元数据属性中提供。

示例

curl -X POST -H "Content-Type: application/json" -d "{\"metadata\":{\"project\":\"project-name\",\"logstore\":\"logstore-name\",\"topic\":\"topic-name\",\"source\":\"source-name\"},\"data\":{\"log-filed\":\"log info\"}" http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

curl -X POST -H "Content-Type: application/json" -d '{"metadata":{"project":"project-name","logstore":"logstore-name","topic":"topic-name","source":"source-name"},"data":{"log-filed":"log info"}' http://localhost:<dapr-port>/v1.0/bindings/<binding-name>

响应格式

由于阿里云 SLS producer API 是异步的，此绑定没有响应（没有回调接口来接收成功或失败的响应，仅在控制台日志中记录任何原因的失败）。

绑定组件规格

Generic

Alibaba Cloud

Amazon Web Services (AWS)

Cloudflare

Google Cloud Platform (GCP)

Microsoft Azure

Zeebe (Camunda Cloud)

1 - Alibaba Cloud DingTalk binding 规范

设置 Dapr 组件

Warning

规范元数据字段

Binding 支持

指定负载

相关链接

2 - Alibaba Cloud Tablestore binding 规范

组件格式

Warning

规范元数据字段

Binding 支持

创建对象

Note

删除对象

Note

列出对象

Note

获取对象

Note

相关链接

3 - Apple Push Notification Service 绑定规范

组件格式

规格元数据字段

私钥

绑定支持

推送通知格式

请求格式

响应格式

相关链接

4 - AWS DynamoDB 绑定规范

组件格式

Warning

规范元数据字段

Important

绑定支持

相关链接

5 - AWS Kinesis 绑定规范

组件格式

警告

规范元数据字段

重要

绑定支持

相关链接

6 - AWS S3 绑定规范

组件格式

警告

规范元数据字段

重要

S3 存储桶创建

与 Minio 一起使用

绑定支持

创建对象

使用预签名 URL 共享对象

响应

示例

将文本保存到随机生成的 UUID 文件

将文本保存到特定文件

将文件保存为对象

从文件路径上传

响应

预签名现有对象

响应

获取对象

示例

响应

删除对象

示例

删除对象

响应

列出对象

响应