• NodeJS & Dapr Javascript SDK 官方使用指南

    image

    Dapr 是一个可移植的、事件驱动的运行时，它使任何开发人员能够轻松构建出弹性的、无状态和有状态的应用程序，并可运行在云平台或边缘计算中，它同时也支持多种编程语言和开发框架。Dapr 确保开发人员专注于编写业务逻辑，不必分神解决分布式系统难题，从而显著提高了生产力。Dapr 降低了构建微服务架构类现代云原生应用的门槛。

    系列

    JavaScript

    用于在 JavaScript 和 TypeScript 中构建 Dapr 应用程序的客户端库。该客户端抽象了公共 Dapr API，例如服务到服务调用、状态管理、发布/订阅、机密等，并为构建应用程序提供了一个简单、直观的 API。

    安装

    要开始使用 Javascript SDK，请从 NPM 安装 Dapr JavaScript SDK 包：

    npm install --save @dapr/dapr

    ⚠️ dapr-client 现在已弃用。 请参阅#259 了解更多信息。

    结构

    Dapr Javascript SDK 包含两个主要组件：

    • DaprServer: 管理所有 Dapr sidecar 到应用程序的通信。
    • DaprClient: 管理所有应用程序到 Dapr sidecar 的通信。

    上述通信可以配置为使用 gRPC 或 HTTP 协议。

    image

    Client

    介绍

    Dapr Client 允许您与 Dapr Sidecar 通信并访问其面向客户端的功能，例如发布事件、调用输出绑定、状态管理、Secret 管理等等。

    前提条件

    安装和导入 Dapr 的 JS SDK

    1. 使用 npm 安装 SDK：
    npm i @dapr/dapr --save
    1. 导入库：
    1. import { DaprClient, DaprServer, HttpMethod, CommunicationProtocolEnum } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; // Dapr Sidecar Host
    4. const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
    5. const serverHost = "127.0.0.1"; // App Host of this Example Server
    6. const serverPort = "50051"; // App Port of this Example Server 
    7.  
    8. // HTTP Example
    9. const client = new DaprClient(daprHost, daprPort);
    10.  
    11. // GRPC Example
    12. const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);

    运行

    要运行示例，您可以使用两种不同的协议与 Dapr sidecar 交互：HTTP(默认)或 gRPC。

    使用 HTTP(默认)

    1. import { DaprClient } from "@dapr/dapr";
    2. const client = new DaprClient(daprHost, daprPort);
    1. # Using dapr run
    2. dapr run --app-id example-sdk --app-protocol http -- npm run start
    3.  
    4. # or, using npm script
    5. npm run start:dapr-http

    使用 gRPC

    由于 HTTP 是默认设置，因此您必须调整通信协议以使用 gRPC。 您可以通过向客户端或服务器构造函数传递一个额外的参数来做到这一点。

    1. import { DaprClient, CommunicationProtocol } from "@dapr/dapr";
    2. const client = new DaprClient(daprHost, daprPort, CommunicationProtocol.GRPC);
    1. # Using dapr run
    2. dapr run --app-id example-sdk --app-protocol grpc -- npm run start
    3.  
    4. # or, using npm script
    5. npm run start:dapr-grpc

    代理请求

    通过代理请求，我们可以利用 Dapr 通过其 sidecar 架构带来的独特功能，例如服务发现、日志记录等，使我们能够立即“升级”我们的 gRPC 服务。 gRPC 代理的这一特性在community call 41 中得到了展示。

    community call 41

    https://www.youtube.com/watch?v=B_vkXqptpXY&t=71s

    创建代理

    要执行 gRPC 代理，只需调用 client.proxy.create() 方法创建一个代理：

    1. // As always, create a client to our dapr sidecar
    2. // this client takes care of making sure the sidecar is started, that we can communicate, ...
    3. const clientSidecar = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);
    4.  
    5. // Create a Proxy that allows us to use our gRPC code
    6. const clientProxy = await clientSidecar.proxy.create<GreeterClient>(GreeterClient);

    我们现在可以调用 GreeterClient 接口中定义的方法(在本例中来自 Hello World 示例)

    幕后(技术工作)

    1. gRPC 服务在 Dapr 中启动。 我们通过 --app-port 告诉 Dapr 这个 gRPC 服务器在哪个端口上运行，并通过 --app-id 给它一个唯一的 Dapr 应用 ID
    2. 我们现在可以通过将连接到 Sidecar 的客户端调用 Dapr Sidecar
    3. 在调用 Dapr Sidecar 时，我们提供了一个名为 dapr-app-id 的元数据键，其中包含在 Dapr 中启动的 gRPC 服务器的值(例如，我们示例中的 server)
    4. Dapr 现在会将调用转发到配置的 gRPC 服务器

    构建块

    JavaScript 客户端 SDK 允许您与专注于 Client to Sidecar 功能的所有 Dapr 构建块进行交互。

    调用 API

    调用一个服务

    1. import { DaprClient, HttpMethod } from "@dapr/dapr"; 
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5.  
    6. async function start() {
    7.   const client = new DaprClient(daprHost, daprPort); 
    8.  
    9.   const serviceAppId = "my-app-id";
    10.   const serviceMethod = "say-hello";
    11.   
    12.   // POST Request
    13.   const response = await client.invoker.invoke(serviceAppId , serviceMethod , HttpMethod.POST, { hello: "world" });
    14.  
    15.   // GET Request
    16.   const response = await client.invoker.invoke(serviceAppId , serviceMethod , HttpMethod.GET);
    17. }
    18.  
    19. start().catch((e) => {
    20.   console.error(e);
    21.   process.exit(1);
    22. });
    有关服务调用的完整指南，请访问 How-To: Invoke a service。

    https://docs.dapr.io/developing-applications/building-blocks/service-invocation/howto-invoke-discover-services/

    状态管理 API

    保存、获取和删除应用程序状态

    1. import { DaprClient } from "@dapr/dapr"; 
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5.  
    6. async function start() {
    7.   const client = new DaprClient(daprHost, daprPort); 
    8.  
    9.   const serviceStoreName = "my-state-store-name";
    10.  
    11.   // Save State
    12.   const response = await client.state.save(serviceStoreName, [
    13.     {
    14.       key: "first-key-name",
    15.       value: "hello"
    16.     },
    17.     {
    18.       key: "second-key-name",
    19.       value: "world"
    20.     }
    21.   ]);
    22.  
    23.   // Get State
    24.   const response = await client.state.get(serviceStoreName, "first-key-name");
    25.  
    26.   // Get Bulk State
    27.   const response = await client.state.getBulk(serviceStoreName, ["first-key-name", "second-key-name"]);
    28.  
    29.   // State Transactions
    30.   await client.state.transaction(serviceStoreName, [
    31.     {
    32.       operation: "upsert",
    33.       request: {
    34.         key: "first-key-name",
    35.         value: "new-data"
    36.       }
    37.     },
    38.     {
    39.       operation: "delete",
    40.       request: {
    41.         key: "second-key-name"
    42.       }
    43.     }
    44.   ]);
    45.  
    46.   // Delete State
    47.   const response = await client.state.delete(serviceStoreName, "first-key-name");
    48. }
    49.  
    50. start().catch((e) => {
    51.   console.error(e);
    52.   process.exit(1);
    53. });
    有关状态操作的完整列表，请访问 How-To: Get & save state。

    https://docs.dapr.io/developing-applications/building-blocks/state-management/howto-get-save-state/

    查询状态 API

    1. import { DaprClient } from "@dapr/dapr";
    2.  
    3. async function start() {
    4.   const client = new DaprClient(daprHost, daprPort);
    5.  
    6.   const res = await client.state.query("state-mongodb", {
    7.     filter: {
    8.       OR: [
    9.         {
    10.           EQ: { "person.org": "Dev Ops" }
    11.         },
    12.         {
    13.           "AND": [
    14.             {
    15.               "EQ": { "person.org": "Finance" }
    16.             },
    17.             {
    18.               "IN": { "state": ["CA", "WA"] }
    19.             }
    20.           ]
    21.         }
    22.       ]
    23.     },
    24.     sort: [
    25.       {
    26.         key: "state",
    27.         order: "DESC"
    28.       }
    29.     ],
    30.     page: {
    31.       limit: 10
    32.     }
    33.   });
    34.  
    35.   console.log(res);
    36. }
    37.  
    38. start().catch((e) => {
    39.   console.error(e);
    40.   process.exit(1);
    41. });

    发布订阅 API

    发布消息

    1. import { DaprClient } from "@dapr/dapr"; 
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5.  
    6. async function start() {
    7.   const client = new DaprClient(daprHost, daprPort); 
    8.  
    9.   const pubSubName = "my-pubsub-name";
    10.   const topic = "topic-a";
    11.   const message = { hello: "world" }
    12.  
    13.   // Publish Message to Topic
    14.   const response = await client.pubsub.publish(pubSubName, topic, message);
    15. }
    16.  
    17. start().catch((e) => {
    18.   console.error(e);
    19.   process.exit(1);
    20. });

    订阅消息

    1. import { DaprServer } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; // Dapr Sidecar Host
    4. const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
    5. const serverHost = "127.0.0.1"; // App Host of this Example Server
    6. const serverPort = "50051"; // App Port of this Example Server "
    7.  
    8. async function start() {
    9.   const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
    10.  
    11.   const pubSubName = "my-pubsub-name";
    12.   const topic = "topic-a";
    13.  
    14.   // Configure Subscriber for a Topic
    15.   await server.pubsub.subscribe(pubSubName, topic, async (data: any) => console.log(`Got Data: ${JSON.stringify(data)}`));
    16.  
    17.   await server.start();
    18. }
    有关状态操作的完整列表，请访问 How-To: Publish and subscribe。

    https://docs.dapr.io/developing-applications/building-blocks/pubsub/howto-publish-subscribe/

    绑定 API

    调用输出绑定

    1. import { DaprClient } from "@dapr/dapr"; 
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5.  
    6. async function start() {
    7.   const client = new DaprClient(daprHost, daprPort); 
    8.  
    9.   const bindingName = "my-binding-name";
    10.   const bindingOperation = "create";
    11.   const message = { hello: "world" };
    12.  
    13.   const response = await client.binding.send(bindingName, bindingOperation, message);
    14. }
    15.  
    16. start().catch((e) => {
    17.   console.error(e);
    18.   process.exit(1);
    19. });
    有关输出绑定的完整指南，请访问 How-To: Use bindings。

    https://docs.dapr.io/developing-applications/building-blocks/bindings/howto-bindings/

    Secret API

    检索 secret

    1. import { DaprClient } from "@dapr/dapr"; 
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5.  
    6. async function start() {
    7.   const client = new DaprClient(daprHost, daprPort); 
    8.  
    9.   const secretStoreName = "my-secret-store";
    10.   const secretKey = "secret-key";
    11.  
    12.   // Retrieve a single secret from secret store
    13.   const response = await client.secret.get(secretStoreName, secretKey);
    14.  
    15.   // Retrieve all secrets from secret store
    16.   const response = await client.secret.getBulk(secretStoreName);
    17. }
    18.  
    19. start().catch((e) => {
    20.   console.error(e);
    21.   process.exit(1);
    22. });
    有关 secrets 的完整指南，请访问 How-To: Retrieve Secrets。

    https://docs.dapr.io/developing-applications/building-blocks/secrets/howto-secrets/

    配置 API

    获取配置 key

    1. import { DaprClient } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1";
    4. const daprAppId = "example-config";
    5.  
    6. async function start() {
    7.  
    8.   const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT);
    9.  
    10.   const config = await client.configuration.get('config-store', ['key1', 'key2']);
    11.   console.log(config);
    12. }
    13.  
    14. start().catch((e) => {
    15.   console.error(e);
    16.   process.exit(1);
    17. });

    Server

    介绍

    Dapr Server 将允许您接收来自 Dapr Sidecar 的通信并访问其面向服务器的功能，例如：订阅事件、接收输入绑定等等。

    前提条件

    安装和导入 Dapr 的 JS SDK

    1. 使用 npm 安装 SDK：
    npm i @dapr/dapr --save
    1. 导入库：
    1. import { DaprClient, DaprServer, HttpMethod, CommunicationProtocolEnum } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; // Dapr Sidecar Host
    4. const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
    5. const serverHost = "127.0.0.1"; // App Host of this Example Server
    6. const serverPort = "50051"; // App Port of this Example Server 
    7.  
    8. // HTTP Example
    9. const client = new DaprClient(daprHost, daprPort);
    10.  
    11. // GRPC Example
    12. const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);

    运行

    要运行示例，您可以使用两种不同的协议与 Dapr sidecar 交互：HTTP(默认)或 gRPC。

    使用 HTTP(默认)

    1. import { DaprServer } from "@dapr/dapr";
    2.  
    3. const server= new DaprServer(appHost, appPort, daprHost, daprPort);
    4. // initialize subscribtions, ... before server start
    5. // the dapr sidecar relies on these
    6. await server.start();
    1. # Using dapr run
    2. dapr run --app-id example-sdk --app-port 50051 --app-protocol http -- npm run start
    3.  
    4. # or, using npm script
    5. npm run start:dapr-http
    ℹ️ Note：这里需要 app-port，因为这是我们的服务器需要绑定的地方。 Dapr 将在完成启动之前检查应用程序是否绑定到此端口。

    使用 gRPC

    由于 HTTP 是默认设置，因此您必须调整通信协议以使用 gRPC。 您可以通过向客户端或服务器构造函数传递一个额外的参数来做到这一点。

    1. import { DaprServer, CommunicationProtocol } from "@dapr/dapr";
    2.  
    3. const server = new DaprServer(appHost, appPort, daprHost, daprPort, CommunicationProtocol.GRPC);
    4. // initialize subscribtions, ... before server start
    5. // the dapr sidecar relies on these
    6. await server.start();
    1. # Using dapr run
    2. dapr run --app-id example-sdk --app-port 50051 --app-protocol grpc -- npm run start
    3.  
    4. # or, using npm script
    5. npm run start:dapr-grpc
    ℹ️ Note：这里需要 app-port，因为这是我们的服务器需要绑定的地方。 Dapr 将在完成启动之前检查应用程序是否绑定到此端口。

    构建块

    JavaScript Server SDK 允许您与专注于 Sidecar 到 App 功能的所有 Dapr 构建块进行交互。

    调用 API

    监听调用

    1. import { DaprServer } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; // Dapr Sidecar Host
    4. const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
    5. const serverHost = "127.0.0.1"; // App Host of this Example Server
    6. const serverPort = "50051"; // App Port of this Example Server "
    7.  
    8. async function start() {
    9.   const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
    10.  
    11.   await server.invoker.listen('hello-world', mock, { method: HttpMethod.GET });
    12.  
    13.   // You can now invoke the service with your app id and method "hello-world"
    14.  
    15.   await server.start();
    16. }
    17.  
    18. start().catch((e) => {
    19.   console.error(e);
    20.   process.exit(1);
    21. });
    有关服务调用的完整指南，请访问 How-To: Invoke a service。

    https://docs.dapr.io/developing-applications/building-blocks/service-invocation/howto-invoke-discover-services/

    发布订阅 API

    订阅消息

    1. import { DaprServer } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; // Dapr Sidecar Host
    4. const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
    5. const serverHost = "127.0.0.1"; // App Host of this Example Server
    6. const serverPort = "50051"; // App Port of this Example Server "
    7.  
    8. async function start() {
    9.   const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
    10.  
    11.   const pubSubName = "my-pubsub-name";
    12.   const topic = "topic-a";
    13.  
    14.   // Configure Subscriber for a Topic
    15.   await server.pubsub.subscribe(pubSubName, topic, async (data: any) => console.log(`Got Data: ${JSON.stringify(data)}`));
    16.  
    17.   await server.start();
    18. }
    19.  
    20. start().catch((e) => {
    21.   console.error(e);
    22.   process.exit(1);
    23. });
    有关状态操作的完整列表，请访问 How-To: Publish and subscribe。

    https://docs.dapr.io/developing-applications/building-blocks/pubsub/howto-publish-subscribe/

    绑定 API

    接收一个输入绑定

    1. import { DaprServer } from "@dapr/dapr";
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5. const serverHost = "127.0.0.1";
    6. const serverPort = "5051";
    7.  
    8. async function start() {
    9.   const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
    10.  
    11.   const bindingName = "my-binding-name";
    12.  
    13.   const response = await server.binding.receive(bindingName, async (data: any) => console.log(`Got Data: ${JSON.stringify(data)}`));
    14.  
    15.   await server.start();
    16. }
    17.  
    18. start().catch((e) => {
    19.   console.error(e);
    20.   process.exit(1);
    21. });
    有关输出绑定的完整指南，请访问 How-To: Use bindings。

    https://docs.dapr.io/developing-applications/building-blocks/bindings/howto-bindings/

    配置 API

    💡 配置 API 目前只能通过 gRPC 使用

    获取配置值

    1. import { DaprServer } from "dapr-client";
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5. const serverHost = "127.0.0.1";
    6. const serverPort = "5051";
    7.  
    8. async function start() {
    9.     const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);
    10.     const config = await client.configuration.get("config-redis", ["myconfigkey1", "myconfigkey2"]);
    11. }
    12.  
    13. start().catch((e) => {
    14.   console.error(e);
    15.   process.exit(1);
    16. });

    订阅 key 更改

    1. import { DaprServer } from "dapr-client";
    2.  
    3. const daprHost = "127.0.0.1"; 
    4. const daprPort = "3500"; 
    5. const serverHost = "127.0.0.1";
    6. const serverPort = "5051";
    7.  
    8. async function start() {
    9.     const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);
    10.     const stream = await client.configuration.subscribeWithKeys("config-redis", ["myconfigkey1", "myconfigkey2"], () => {
    11.         // Received a key update
    12.     });
    13.  
    14.     // When you are ready to stop listening, call the following
    15.     await stream.close();
    16. }
    17.  
    18. start().catch((e) => {
    19.   console.error(e);
    20.   process.exit(1);
    21. });

    Actors

    Dapr actors 包允许您从 JavaScript 应用程序与 Dapr virtual actors 进行交互。下面的示例演示了如何使用 JavaScript SDK 与 virtual actors 进行交互。

    如需更深入地了解 Dapr actors，请访问 actors 概览页面。

    前提条件

    场景

    下面的代码示例粗略地描述了停车场现场监控系统的场景，可以在 Mark Russinovich 的这段视频中看到。

    一个停车场由数百个停车位组成，每个停车位都包含一个传感器，可为中央监控系统提供更新。 停车位传感器(我们的 actors)检测停车位是否被占用或可用。

    要自己跳入并运行此示例，请克隆源代码，该源代码可在 JavaScript SDK 示例目录中找到。

    Actor 接口

    Actor 接口定义了在 Actor 实现和调用 Actor 的客户端之间共享的合约。 在下面的示例中，我们为停车场传感器创建了一个接口。 每个传感器有 2 个方法：carEnter 和 carLeave，它们定义了停车位的状态：

    1. export default interface ParkingSensorInterface {
    2.   carEnter(): Promise<void>;
    3.   carLeave(): Promise<void>;
    4. }

    Actor 实现

    Actor 实现通过扩展基本类型 AbstractActor 并实现 Actor 接口(在本例中为 ParkingSensorInterface)来定义一个类。

    下面的代码描述了一个 actor 实现以及一些辅助方法。

    1. import { AbstractActor } from "@dapr/dapr";
    2. import ParkingSensorInterface from "./ParkingSensorInterface";
    3.  
    4. export default class ParkingSensorImpl extends AbstractActor implements ParkingSensorInterface {
    5.   async carEnter(): Promise<void> {
    6.     // Implementation that updates state that this parking spaces is occupied.
    7.   }
    8.  
    9.   async carLeave(): Promise<void> {
    10.     // Implementation that updates state that this parking spaces is available.
    11.   }
    12.  
    13.   private async getInfo(): Promise<object> {
    14.     // Implementation of requesting an update from the parking space sensor.
    15.   }
    16.  
    17.   /**
    18.    * @override
    19.    */
    20.   async onActivate(): Promise<void> {
    21.     // Initialization logic called by AbstractActor.
    22.   }
    23. }

    注册 Actor

    使用 DaprServer 包初始化和注册你的 actors：

    1. import { DaprServer } from "@dapr/dapr";
    2. import ParkingSensorImpl from "./ParkingSensorImpl";
    3.  
    4. const daprHost = "127.0.0.1";
    5. const daprPort = "50000";
    6. const serverHost = "127.0.0.1";
    7. const serverPort = "50001";
    8.  
    9. const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
    10.  
    11. await server.actor.init(); // Let the server know we need actors
    12. server.actor.registerActor(ParkingSensorImpl); // Register the actor
    13. await server.start(); // Start the server
    14.  
    15. // To get the registered actors, you can invoke `getRegisteredActors`:
    16. const resRegisteredActors = await server.actor.getRegisteredActors();
    17. console.log(`Registered Actors: ${JSON.stringify(resRegisteredActors)}`);

    调用 Actor 方法

    注册 Actor 后，使用 ActorProxyBuilder 创建一个实现 ParkingSensorInterface 的代理对象。 您可以通过直接调用 Proxy 对象上的方法来调用 actor 方法。在内部，它转换为对 Actor API 进行网络调用并取回结果。

    1. import { DaprClient, ActorId } from "@dapr/dapr";
    2. import ParkingSensorImpl from "./ParkingSensorImpl";
    3. import ParkingSensorInterface from "./ParkingSensorInterface";
    4.  
    5. const daprHost = "127.0.0.1";
    6. const daprPort = "50000";
    7.  
    8. const client = new DaprClient(daprHost, daprPort);
    9.  
    10. // Create a new actor builder. It can be used to create multiple actors of a type.
    11. const builder = new ActorProxyBuilder<ParkingSensorInterface>(ParkingSensorImpl, client);
    12.  
    13. // Create a new actor instance.
    14. const actor = builder.build(new ActorId("my-actor"));
    15. // Or alternatively, use a random ID
    16. // const actor = builder.build(ActorId.createRandomId());
    17.  
    18. // Invoke the method.
    19. await actor.carEnter();

    将状态与 Actor 一起使用

    1. // ...
    2.  
    3. const PARKING_SENSOR_PARKED_STATE_NAME = "parking-sensor-parked"
    4.  
    5. const actor = builder.build(new ActorId("my-actor")) 
    6.  
    7. // SET state
    8. await actor.getStateManager().setState(PARKING_SENSOR_PARKED_STATE_NAME, true);
    9.  
    10. // GET state
    11. const value = await actor.getStateManager().getState(PARKING_SENSOR_PARKED_STATE_NAME);
    12. if (!value) {
    13.   console.log(`Received: ${value}!`);
    14. }
    15.  
    16. // DELETE state
    17. await actor.removeState(PARKING_SENSOR_PARKED_STATE_NAME);
    18. ...

    Actor 计时器和提醒器

    JS SDK 支持 actors 可以通过注册 timers 或 reminders 来为自己安排定期工作。timers 和 reminders 之间的主要区别在于，Dapr actor runtime 在停用后不保留有关 timers 的任何信息，而是使用 Dapr actor state provider 保留 reminders 信息。

    这种区别允许用户在轻量级但无状态的 timers 和更需要资源但有状态的 reminders 之间进行权衡。

    Timers 和 reminders 的调度界面是相同的。要更深入地了解调度配置，请参阅 actors timers 和 reminders 文档。

    Actor Timers

    1. // ...
    2.  
    3. const actor = builder.build(new ActorId("my-actor"));
    4.  
    5. // Register a timer
    6. await actor.registerActorTimer(
    7.   "timer-id", // Unique name of the timer.
    8.   "cb-method", // Callback method to execute when timer is fired.
    9.   Temporal.Duration.from({ seconds: 2 }), // DueTime
    10.   Temporal.Duration.from({ seconds: 1 }), // Period
    11.   Temporal.Duration.from({ seconds: 1 }), // TTL
    12.   50 // State to be sent to timer callback.
    13. );
    14.  
    15. // Delete the timer
    16. await actor.unregisterActorTimer("timer-id");

    Actor Reminders

    1. // ...
    2.  
    3. const actor = builder.build(new ActorId("my-actor"));
    4.  
    5. // Register a reminder, it has a default callback: `receiveReminder`
    6. await actor.registerActorReminder(
    7.   "reminder-id", // Unique name of the reminder.
    8.   Temporal.Duration.from({ seconds: 2 }), // DueTime
    9.   Temporal.Duration.from({ seconds: 1 }), // Period
    10.   Temporal.Duration.from({ seconds: 1 }), // TTL
    11.   100 // State to be sent to reminder callback.
    12. );
    13.  
    14. // Delete the reminder
    15. await actor.unregisterActorReminder("reminder-id");

    要处理回调，您需要覆盖 actor 中的默认 receiveReminder 实现。 例如，从我们最初的 actor 实现中：

    1. export default class ParkingSensorImpl extends AbstractActor implements ParkingSensorInterface {
    2.   // ...
    3.  
    4.   /**
    5.    * @override
    6.    */
    7.   async receiveReminder(state: any): Promise<void> {
    8.     // handle stuff here
    9.   }
    10.  
    11.   // ...
    12. }

    有关 actors 的完整指南，请访问 How-To: Use virtual actors in Dapr。

    Logging

    介绍

    JavaScript SDK 带有一个开箱即用的基于 Console 的 logger。SDK 发出各种内部日志，以帮助用户了解事件链并解决问题。此 SDK 的使用者可以自定义日志的详细程度，并为 logger 提供自己的实现。

    配置日志级别

    有五个级别的日志记录，按重要性降序排列 - error、warn、info、verbose 和 debug。 将日志设置为一个级别意味着 logger 将发出至少与上述级别一样重要的所有日志。 例如，设置为 verbose 日志意味着 SDK 不会发出 debug 级别的日志。默认日志级别是 info。

    Dapr Client

    1. import { CommunicationProtocolEnum, DaprClient, LogLevel } from "@dapr/dapr";
    2.  
    3. // create a client instance with log level set to verbose.
    4. const client = new DaprClient(
    5.     daprHost, 
    6.     daprPort, 
    7.     CommunicationProtocolEnum.HTTP, 
    8.     { logger: { level: LogLevel.Verbose } });
    有关如何使用 Client 的更多详细信息，请参阅 JavaScript Client。

    https://docs.dapr.io/developing-applications/sdks/js/js-client/

    DaprServer

    1. import { CommunicationProtocolEnum, DaprServer, LogLevel } from "@dapr/dapr";
    2.  
    3. // create a server instance with log level set to error.
    4. const server = new DaprServer(
    5.     serverHost,
    6.     serverPort, 
    7.     daprHost,
    8.     daprPort,
    9.     CommunicationProtocolEnum.HTTP,
    10.     { logger: { level: LogLevel.Error } });
    有关如何使用 Server 的更多详细信息，请参阅 JavaScript Server。

    https://docs.dapr.io/developing-applications/sdks/js/js-server/

    自定义 LoggerService

    JavaScript SDK 使用内置 Console 进行日志记录。要使用 Winston 或 Pino 等自定义 logger，您可以实现 LoggerService 接口。

    基于 Winston 的日志记录：

    创建 LoggerService 的新实现。

    1. import { LoggerService } from "@dapr/dapr";
    2. import * as winston from 'winston';
    3.  
    4. export class WinstonLoggerService implements LoggerService {
    5.     private logger;
    6.  
    7.     constructor() {
    8.         this.logger = winston.createLogger({
    9.             transports: [
    10.                 new winston.transports.Console(),
    11.                 new winston.transports.File({ filename: 'combined.log' })
    12.             ]
    13.         });
    14.     }
    15.  
    16.     error(message: any, ...optionalParams: any[]): void {
    17.         this.logger.error(message, ...optionalParams)
    18.     }
    19.     warn(message: any, ...optionalParams: any[]): void {
    20.         this.logger.warn(message, ...optionalParams)
    21.     }
    22.     info(message: any, ...optionalParams: any[]): void {
    23.         this.logger.info(message, ...optionalParams)
    24.     }
    25.     verbose(message: any, ...optionalParams: any[]): void {
    26.         this.logger.verbose(message, ...optionalParams)
    27.     }
    28.     debug(message: any, ...optionalParams: any[]): void {
    29.         this.logger.debug(message, ...optionalParams)
    30.     }
    31. }

    将新实现传递给 SDK。

    1. import { CommunicationProtocolEnum, DaprClient, LogLevel } from "@dapr/dapr";
    2. import { WinstonLoggerService } from "./WinstonLoggerService";
    3.  
    4. const winstonLoggerService = new WinstonLoggerService();
    5.  
    6. // create a client instance with log level set to verbose and logger service as winston.
    7. const client = new DaprClient(
    8.     daprHost,
    9.     daprPort,
    10.     CommunicationProtocolEnum.HTTP,
    11.     { logger: { level: LogLevel.Verbose, service: winstonLoggerService } });

    官方示例代码库

  • 相关阅读:
    【uni-app系列】uni-app之App打包
    攻防世界-very-easy-sql
    MoneyPrinterPlus全面支持本地Ollama大模型
    Spring boot 处理程序中的异常 配置全局异常捕获
    C++面试八股文：C++中，设计一个类要注意哪些东西？
    【笔试题】【day21】
    ATF安全漏洞挖掘之FUZZ测试
    【初阶算法4】——归并排序的详解，及其归并排序的扩展
    【UnityShader】图片圆角
    2022-08-07 周总结
  • 原文地址：https://blog.csdn.net/o__cc/article/details/126175708