前置条件
对于此示例，您需要：
第 1 步：设置环境
克隆 Quickstarts 仓库中提供的示例。
git clone https://github.com/dapr/quickstarts.git
第 2 步：在本地运行 PostgreSQL Docker 容器
在您的机器上的 Docker 容器中本地运行 PostgreSQL 实例。快速入门示例包含一个 Docker Compose 文件，用于在本地自定义、构建、运行和初始化带有默认 orders 表的 postgres 容器。
在终端窗口中，从 Quickstarts 克隆目录的根目录导航到 bindings/db 目录。
运行以下命令来设置容器：
验证容器是否在本地运行。
输出应包括：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
55305d1d378b postgres "docker-entrypoint.s…" 3 seconds ago Up 2 seconds 0.0.0.0:5432->5432/tcp sql_db
第 3 步：安排 Cron 作业并写入数据库
在新的终端窗口中，导航到 SDK 目录。
cd bindings/python/sdk/batch
安装依赖项：
pip3 install -r requirements.txt
与 Dapr 边车一起运行 batch-sdk 服务。
dapr run --app-id batch-sdk --app-port 50051 --resources-path ../../../components -- python3 app.py
注意：由于 Windows 中未定义 Python3.exe，您可能需要使用 python app.py 而不是 python3 app.py。
process_batch 函数内的代码每 10 秒执行一次（在 components 目录中的 binding-cron.yaml 中定义）。绑定触发器在您的应用程序中寻找由 Dapr 边车通过 HTTP POST 调用的路由。
# 由 Dapr 输入绑定触发
@app.route('/' + cron_binding_name, methods=['POST'])
def process_batch():
batch-sdk 服务使用 binding-postgresql.yaml 组件中定义的 PostgreSQL 输出绑定，将 OrderId、Customer 和 Price 记录插入到 orders 表中。
with DaprClient() as d:
sqlCmd = ('insert into orders (orderid, customer, price) values ' +
'(%s, \'%s\', %s)' % (order_line['orderid'],
order_line['customer'],
order_line['price']))
payload = {'sql': sqlCmd}
print(sqlCmd, flush=True)
try:
# 使用 Dapr 输出绑定通过 HTTP Post 插入订单
resp = d.invoke_binding(binding_name=sql_binding, operation='exec',
binding_metadata=payload, data='')
return resp
except Exception as e:
print(e, flush=True)
raise SystemExit(e)
第 4 步：查看作业的输出
请注意，如上所述，代码使用 OrderId、Customer 和 Price 作为负载调用输出绑定。
您的输出绑定的 print 语句输出：
== APP == Processing batch..
== APP == insert into orders (orderid, customer, price) values (1, 'John Smith', 100.32)
== APP == insert into orders (orderid, customer, price) values (2, 'Jane Bond', 15.4)
== APP == insert into orders (orderid, customer, price) values (3, 'Tony James', 35.56)
== APP == Finished processing batch
在新的终端中，验证相同的数据已插入到数据库中。导航到 bindings/db 目录。
运行以下命令以启动交互式 psql CLI：
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
在 admin=# 提示符下，切换到 orders 表：
在 orders=# 提示符下，选择所有行：
输出应如下所示：
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 Cron 绑定构建块
- 每 10 秒调用一次绑定端点（
batch）
为此快速入门包含的 Cron binding-cron.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: cron
namespace: quickstarts
spec:
type: bindings.cron
version: v1
metadata:
- name: schedule
value: "@every 10s" # valid cron schedule
- name: direction
value: "input" # direction of the cron binding
注意： binding-cron.yaml 的 metadata 部分包含一个 Cron 表达式，用于指定调用绑定的频率。
component\binding-postgresql.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 PostgreSQL 绑定构建块
- 使用
binding-postgresql.yaml 文件中指定的设置连接到 PostgreSQL
使用 binding-postgresql.yaml 组件，您可以轻松更换后端数据库 绑定，而无需更改代码。
为此快速入门包含的 PostgreSQL binding-postgresql.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: sqldb
namespace: quickstarts
spec:
type: bindings.postgresql
version: v1
metadata:
- name: url # Required
value: "user=postgres password=docker host=localhost port=5432 dbname=orders pool_min_conns=1 pool_max_conns=10"
- name: direction
value: "output" # direction of the postgresql binding
在 YAML 文件中：
spec/type 指定此绑定使用 PostgreSQL。spec/metadata 定义组件使用的 PostgreSQL 实例的连接。
前置条件
对于此示例，您需要：
第 1 步：设置环境
克隆 Quickstarts 仓库中提供的示例。
git clone https://github.com/dapr/quickstarts.git
第 2 步：在本地运行 PostgreSQL Docker 容器
在您的机器上的 Docker 容器中本地运行 PostgreSQL 实例。快速入门示例包含一个 Docker Compose 文件，用于在本地自定义、构建、运行和初始化带有默认 orders 表的 postgres 容器。
在终端窗口中，从 Quickstarts 克隆目录的根目录导航到 bindings/db 目录。
运行以下命令来设置容器：
验证容器是否在本地运行。
输出应包括：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
55305d1d378b postgres "docker-entrypoint.s…" 3 seconds ago Up 2 seconds 0.0.0.0:5432->5432/tcp sql_db
第 3 步：安排 Cron 作业并写入数据库
在新的终端窗口中，导航到 SDK 目录。
cd bindings/javascript/sdk/batch
安装依赖项：
与 Dapr 边车一起运行 batch-sdk 服务。
dapr run --app-id batch-sdk --app-port 5002 --dapr-http-port 3500 --resources-path ../../../components -- node index.js
process_batch 函数内的代码每 10 秒执行一次（在 components 目录中的 binding-cron.yaml 中定义）。绑定触发器在您的应用程序中寻找由 Dapr 边车通过 HTTP POST 调用的路由。
async function start() {
await server.binding.receive(cronBindingName,processBatch);
await server.start();
}
batch-sdk 服务使用 binding-postgresql.yaml 组件中定义的 PostgreSQL 输出绑定，将 OrderId、Customer 和 Price 记录插入到 orders 表中。
async function processBatch(){
const loc = '../../orders.json';
fs.readFile(loc, 'utf8', (err, data) => {
const orders = JSON.parse(data).orders;
orders.forEach(order => {
let sqlCmd = `insert into orders (orderid, customer, price) values (${order.orderid}, '${order.customer}', ${order.price});`;
let payload = `{ "sql": "${sqlCmd}" } `;
console.log(payload);
client.binding.send(postgresBindingName, "exec", "", JSON.parse(payload));
});
console.log('Finished processing batch');
});
return 0;
}
第 4 步：查看作业的输出
请注意，如上所述，代码使用 OrderId、Customer 和 Price 作为负载调用输出绑定。
您的输出绑定的 print 语句输出：
== APP == Processing batch..
== APP == insert into orders (orderid, customer, price) values(1, 'John Smith', 100.32)
== APP == insert into orders (orderid, customer, price) values(2, 'Jane Bond', 15.4)
== APP == insert into orders (orderid, customer, price) values(3, 'Tony James', 35.56)
在新的终端中，验证相同的数据已插入到数据库中。导航到 bindings/db 目录。
运行以下命令以启动交互式 Postgres CLI：
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
在 admin=# 提示符下，切换到 orders 表：
在 orders=# 提示符下，选择所有行：
输出应如下所示：
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 Cron 绑定构建块
- 每 10 秒调用一次绑定端点（
batch）
为此快速入门包含的 Cron binding-cron.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: cron
namespace: quickstarts
spec:
type: bindings.cron
version: v1
metadata:
- name: schedule
value: "@every 10s" # valid cron schedule
- name: direction
value: "input" # direction of the cron binding
注意： binding-cron.yaml 的 metadata 部分包含一个 Cron 表达式，用于指定调用绑定的频率。
component\binding-postgresql.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 PostgreSQL 绑定构建块
- 使用
binding-postgresql.yaml 文件中指定的设置连接到 PostgreSQL
使用 binding-postgresql.yaml 组件，您可以轻松更换后端数据库 绑定，而无需更改代码。
为此快速入门包含的 PostgreSQL binding-postgresql.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: sqldb
namespace: quickstarts
spec:
type: bindings.postgresql
version: v1
metadata:
- name: url # Required
value: "user=postgres password=docker host=localhost port=5432 dbname=orders pool_min_conns=1 pool_max_conns=10"
- name: direction
value: "output" # direction of the postgresql binding
在 YAML 文件中：
spec/type 指定此绑定使用 PostgreSQL。spec/metadata 定义组件使用的 PostgreSQL 实例的连接。
前置条件
对于此示例，您需要：
注意： .NET 6 是此版本中 Dapr .NET SDK 包支持的最低 .NET 版本。在 Dapr v1.16 及更高版本中将仅支持 .NET 8 和 .NET 9。
第 1 步：设置环境
克隆 Quickstarts 仓库中提供的示例。
git clone https://github.com/dapr/quickstarts.git
第 2 步：在本地运行 PostgreSQL Docker 容器
在您的机器上的 Docker 容器中本地运行 PostgreSQL 实例。快速入门示例包含一个 Docker Compose 文件，用于在本地自定义、构建、运行和初始化带有默认 orders 表的 postgres 容器。
在终端窗口中，从 Quickstarts 克隆目录的根目录导航到 bindings/db 目录。
运行以下命令来设置容器：
验证容器是否在本地运行。
输出应包括：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
55305d1d378b postgres "docker-entrypoint.s…" 3 seconds ago Up 2 seconds 0.0.0.0:5432->5432/tcp sql_db
第 3 步：安排 Cron 作业并写入数据库
在新的终端窗口中，导航到 SDK 目录。
cd bindings/csharp/sdk/batch
安装依赖项：
dotnet restore
dotnet build batch.csproj
与 Dapr 边车一起运行 batch-sdk 服务。
dapr run --app-id batch-sdk --app-port 7002 --resources-path ../../../components -- dotnet run
process_batch 函数内的代码每 10 秒执行一次（在 components 目录中的 binding-cron.yaml 中定义）。绑定触发器在您的应用程序中寻找由 Dapr 边车通过 HTTP POST 调用的路由。
app.MapPost("/" + cronBindingName, async () => {
// ...
});
batch-sdk 服务使用 binding-postgresql.yaml 组件中定义的 PostgreSQL 输出绑定，将 OrderId、Customer 和 Price 记录插入到 orders 表中。
// ...
string jsonFile = File.ReadAllText("../../../orders.json");
var ordersArray = JsonSerializer.Deserialize<Orders>(jsonFile);
using var client = new DaprClientBuilder().Build();
foreach(Order ord in ordersArray?.orders ?? new Order[] {}){
var sqlText = $"insert into orders (orderid, customer, price) values ({ord.OrderId}, '{ord.Customer}', {ord.Price});";
var command = new Dictionary<string,string>(){
{"sql",
sqlText}
};
// ...
}
// 使用 Dapr 输出绑定通过 Dapr Client SDK 插入订单
await client.InvokeBindingAsync(bindingName: sqlBindingName, operation: "exec", data: "", metadata: command);
第 4 步：查看作业的输出
请注意，如上所述，代码使用 OrderId、Customer 和 Price 作为负载调用输出绑定。
您的输出绑定的 print 语句输出：
== APP == Processing batch..
== APP == insert into orders (orderid, customer, price) values (1, 'John Smith', 100.32);
== APP == insert into orders (orderid, customer, price) values (2, 'Jane Bond', 15.4);
== APP == insert into orders (orderid, customer, price) values (3, 'Tony James', 35.56);
== APP == Finished processing batch
在新的终端中，验证相同的数据已插入到数据库中。导航到 bindings/db 目录。
运行以下命令以启动交互式 Postgres CLI：
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
在 admin=# 提示符下，切换到 orders 表：
在 orders=# 提示符下，选择所有行：
输出应如下所示：
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 Cron 绑定构建块
- 每 10 秒调用一次绑定端点（
batch）
为此快速入门包含的 Cron binding-cron.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: cron
namespace: quickstarts
spec:
type: bindings.cron
version: v1
metadata:
- name: schedule
value: "@every 10s" # valid cron schedule
- name: direction
value: "input" # direction of the cron binding
注意： binding-cron.yaml 的 metadata 部分包含一个 Cron 表达式，用于指定调用绑定的频率。
component\binding-postgresql.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 PostgreSQL 绑定构建块
- 使用
binding-postgresql.yaml 文件中指定的设置连接到 PostgreSQL
使用 binding-postgresql.yaml 组件，您可以轻松更换后端数据库 绑定，而无需更改代码。
为此快速入门包含的 PostgreSQL binding-postgresql.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: sqldb
namespace: quickstarts
spec:
type: bindings.postgresql
version: v1
metadata:
- name: url # Required
value: "user=postgres password=docker host=localhost port=5432 dbname=orders pool_min_conns=1 pool_max_conns=10"
- name: direction
value: "output" # direction of the postgresql binding
在 YAML 文件中：
spec/type 指定此绑定使用 PostgreSQL。spec/metadata 定义组件使用的 PostgreSQL 实例的连接。
前置条件
对于此示例，您需要：
第 1 步：设置环境
克隆 Quickstarts 仓库中提供的示例。
git clone https://github.com/dapr/quickstarts.git
第 2 步：在本地运行 PostgreSQL Docker 容器
在您的机器上的 Docker 容器中本地运行 PostgreSQL 实例。快速入门示例包含一个 Docker Compose 文件，用于在本地自定义、构建、运行和初始化带有默认 orders 表的 postgres 容器。
在终端窗口中，从 Quickstarts 克隆目录的根目录导航到 bindings/db 目录。
运行以下命令来设置容器：
验证容器是否在本地运行。
输出应包括：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
55305d1d378b postgres "docker-entrypoint.s…" 3 seconds ago Up 2 seconds 0.0.0.0:5432->5432/tcp sql_db
第 3 步：安排 Cron 作业并写入数据库
在新的终端窗口中，导航到 SDK 目录。
cd bindings/java/sdk/batch
安装依赖项：
与 Dapr 边车一起运行 batch-sdk 服务。
dapr run --app-id batch-sdk --app-port 8080 --resources-path ../../../components -- java -jar target/BatchProcessingService-0.0.1-SNAPSHOT.jar
process_batch 函数内的代码每 10 秒执行一次（在 components 目录中的 binding-cron.yaml 中定义）。绑定触发器在您的应用程序中寻找由 Dapr 边车通过 HTTP POST 调用的路由。
@PostMapping(path = cronBindingPath, consumes = MediaType.ALL_VALUE)
public ResponseEntity<String> processBatch() throws IOException, Exception
batch-sdk 服务使用 binding-postgresql.yaml 组件中定义的 PostgreSQL 输出绑定，将 OrderId、Customer 和 Price 记录插入到 orders 表中。
try (DaprClient client = new DaprClientBuilder().build()) {
for (Order order : ordList.orders) {
String sqlText = String.format(
"insert into orders (orderid, customer, price) " +
"values (%s, '%s', %s);",
order.orderid, order.customer, order.price);
logger.info(sqlText);
Map<String, String> metadata = new HashMap<String, String>();
metadata.put("sql", sqlText);
// 使用 Dapr SDK 调用 sql 输出绑定
client.invokeBinding(sqlBindingName, "exec", null, metadata).block();
}
logger.info("Finished processing batch");
return ResponseEntity.ok("Finished processing batch");
}
第 4 步：查看作业的输出
请注意，如上所述，代码使用 OrderId、Customer 和 Price 作为负载调用输出绑定。
您的输出绑定的 print 语句输出：
== APP == 2022-06-22 16:39:17.012 INFO 35772 --- [nio-8080-exec-4] c.s.c.BatchProcessingServiceController : Processing batch..
== APP == 2022-06-22 16:39:17.268 INFO 35772 --- [nio-8080-exec-4] c.s.c.BatchProcessingServiceController : insert into orders (orderid, customer, price) values (1, 'John Smith', 100.32);
== APP == 2022-06-22 16:39:17.838 INFO 35772 --- [nio-8080-exec-4] c.s.c.BatchProcessingServiceController : insert into orders (orderid, customer, price) values (2, 'Jane Bond', 15.4);
== APP == 2022-06-22 16:39:17.844 INFO 35772 --- [nio-8080-exec-4] c.s.c.BatchProcessingServiceController : insert into orders (orderid, customer, price) values (3, 'Tony James', 35.56);
== APP == 2022-06-22 16:39:17.848 INFO 35772 --- [nio-8080-exec-4] c.s.c.BatchProcessingServiceController : Finished processing batch
在新的终端中，验证相同的数据已插入到数据库中。导航到 bindings/db 目录。
运行以下命令以启动交互式 Postgres CLI：
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
在 admin=# 提示符下，切换到 orders 表：
在 orders=# 提示符下，选择所有行：
输出应如下所示：
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 Cron 绑定构建块
- 每 10 秒调用一次绑定端点（
batch）
为此快速入门包含的 Cron binding-cron.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: cron
namespace: quickstarts
spec:
type: bindings.cron
version: v1
metadata:
- name: schedule
value: "@every 10s" # valid cron schedule
- name: direction
value: "input" # direction of the cron binding
注意： binding-cron.yaml 的 metadata 部分包含一个 Cron 表达式，用于指定调用绑定的频率。
component\binding-postgresql.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 PostgreSQL 绑定构建块
- 使用
binding-postgresql.yaml 文件中指定的设置连接到 PostgreSQL
使用 binding-postgresql.yaml 组件，您可以轻松更换后端数据库 绑定，而无需更改代码。
为此快速入门包含的 PostgreSQL binding-postgresql.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: sqldb
namespace: quickstarts
spec:
type: bindings.postgresql
version: v1
metadata:
- name: url # Required
value: "user=postgres password=docker host=localhost port=5432 dbname=orders pool_min_conns=1 pool_max_conns=10"
- name: direction
value: "output" # direction of the postgresql binding
在 YAML 文件中：
spec/type 指定此绑定使用 PostgreSQL。spec/metadata 定义组件使用的 PostgreSQL 实例的连接。
前置条件
对于此示例，您需要：
第 1 步：设置环境
克隆 Quickstarts 仓库中提供的示例。
git clone https://github.com/dapr/quickstarts.git
第 2 步：在本地运行 PostgreSQL Docker 容器
在您的机器上的 Docker 容器中本地运行 PostgreSQL 实例。快速入门示例包含一个 Docker Compose 文件，用于在本地自定义、构建、运行和初始化带有默认 orders 表的 postgres 容器。
在终端窗口中，从 Quickstarts 克隆目录的根目录导航到 bindings/db 目录。
运行以下命令来设置容器：
验证容器是否在本地运行。
输出应包括：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
55305d1d378b postgres "docker-entrypoint.s…" 3 seconds ago Up 2 seconds 0.0.0.0:5432->5432/tcp sql_db
第 3 步：安排 Cron 作业并写入数据库
在新的终端窗口中，导航到 SDK 目录。
安装依赖项：
与 Dapr 边车一起运行 batch-sdk 服务。
dapr run --app-id batch-sdk --app-port 6002 --dapr-http-port 3502 --dapr-grpc-port 60002 --resources-path ../../../components -- go run .
process_batch 函数内的代码每 10 秒执行一次（在 components 目录中的 binding-cron.yaml 中定义）。绑定触发器在您的应用程序中寻找由 Dapr 边车通过 HTTP POST 调用的路由。
// 由 Dapr 输入绑定触发
r.HandleFunc("/"+cronBindingName, processBatch).Methods("POST")
batch-sdk 服务使用 binding-postgresql.yaml 组件中定义的 PostgreSQL 输出绑定，将 OrderId、Customer 和 Price 记录插入到 orders 表中。
func sqlOutput(order Order) (err error) {
client, err := dapr.NewClient()
if err != nil {
return err
}
ctx := context.Background()
sqlCmd := fmt.Sprintf("insert into orders (orderid, customer, price) values (%d, '%s', %s);", order.OrderId, order.Customer, strconv.FormatFloat(order.Price, 'f', 2, 64))
fmt.Println(sqlCmd)
// 使用 Dapr 输出绑定通过 Dapr SDK 插入订单
in := &dapr.InvokeBindingRequest{
Name: sqlBindingName,
Operation: "exec",
Data: []byte(""),
Metadata: map[string]string{"sql": sqlCmd},
}
err = client.InvokeOutputBinding(ctx, in)
if err != nil {
return err
}
return nil
}
第 4 步：查看作业的输出
请注意，如上所述，代码使用 OrderId、Customer 和 Price 作为负载调用输出绑定。
您的输出绑定的 print 语句输出：
== APP == Processing batch..
== APP == insert into orders (orderid, customer, price) values(1, 'John Smith', 100.32)
== APP == insert into orders (orderid, customer, price) values(2, 'Jane Bond', 15.4)
== APP == insert into orders (orderid, customer, price) values(3, 'Tony James', 35.56)
在新的终端中，验证相同的数据已插入到数据库中。导航到 bindings/db 目录。
运行以下命令以启动交互式 Postgres CLI：
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
在 admin=# 提示符下，切换到 orders 表：
在 orders=# 提示符下，选择所有行：
输出应如下所示：
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 Cron 绑定构建块
- 每 10 秒调用一次绑定端点（
batch）
为此快速入门包含的 Cron binding-cron.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: cron
namespace: quickstarts
spec:
type: bindings.cron
version: v1
metadata:
- name: schedule
value: "@every 10s" # valid cron schedule
- name: direction
value: "input" # direction of the cron binding
注意： binding-cron.yaml 的 metadata 部分包含一个 Cron 表达式，用于指定调用绑定的频率。
component\binding-postgresql.yaml 组件文件
当您执行 dapr run 命令并指定组件路径时，Dapr 边车：
- 启动 PostgreSQL 绑定构建块
- 使用
binding-postgresql.yaml 文件中指定的设置连接到 PostgreSQL
使用 binding-postgresql.yaml 组件，您可以轻松更换后端数据库 绑定，而无需更改代码。
为此快速入门包含的 PostgreSQL binding-postgresql.yaml 文件包含以下内容：
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: sqldb
namespace: quickstarts
spec:
type: bindings.postgresql
version: v1
metadata:
- name: url # Required
value: "user=postgres password=docker host=localhost port=5432 dbname=orders pool_min_conns=1 pool_max_conns=10"
- name: direction
value: "output" # direction of the postgresql binding
在 YAML 文件中：
spec/type 指定此绑定使用 PostgreSQL。spec/metadata 定义组件使用的 PostgreSQL 实例的连接。
