How-To: Save and get state

Use key value pairs to persist a state

Introduction

State management is one of the most common needs of any application: new or legacy, monolith or microservice. Dealing with different databases libraries, testing them, handling retries and faults can be time consuming and hard.

Dapr provides state management capabilities that include consistency and concurrency options. In this guide we’ll start of with the basics: Using the key/value state API to allow an application to save, get and delete state.

Pre-requisites

Example:

The below code examples loosely describe an application that processes orders. In the examples, there is an order processing service which has a Dapr sidecar. The order processing service uses Dapr to store state in a Redis state store.

Diagram showing state management of example service

Step 1: Setup a state store

A state store component represents a resource that Dapr uses to communicate with a database.

For the purpose of this guide we’ll use a Redis state store, but any state store from the supported list will work.

When using dapr init in Standalone mode, the Dapr CLI automatically provisions a state store (Redis) and creates the relevant YAML in a components directory, which for Linux/MacOS is $HOME/.dapr/components and for Windows is %USERPROFILE%\.dapr\components

To optionally change the state store being used, replace the YAML file statestore.yaml under /components with the file of your choice.

To deploy this into a Kubernetes cluster, fill in the metadata connection details of your desired statestore component in the yaml below, save as statestore.yaml, and run kubectl apply -f statestore.yaml.

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Component
  3. metadata:
  4.   name: statestore
  5.   namespace: default
  6. spec:
  7.   type: state.redis
  8.   version: v1
  9.   metadata:
  10.   - name: redisHost
  11.     value: localhost:6379
  12.   - name: redisPassword
  13.     value: ""

See the instructions here on how to setup different state stores on Kubernetes.

Step 2: Save and retrieve a single state

The following example shows how to save and retrieve a single key/value pair using the Dapr state building block.

Note

It is important to set an app-id, as the state keys are prefixed with this value. If you don’t set it one is generated for you at runtime, and the next time you run the command a new one will be generated and you will no longer be able to access previously saved state.

Below are code examples that leverage Dapr SDKs for saving and retrieving a single state.

  2. //dependencies
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Net.Http;
  6. using System.Net.Http.Headers;
  7. using System.Threading.Tasks;
  8. using Dapr.Client;
  9. using Microsoft.AspNetCore.Mvc;
  10. using System.Threading;
  11. using System.Text.Json;
  13. //code
  14. namespace EventService
  15. {
  16.     class Program
  17.     {
  18.         static async Task Main(string[] args)
  19.         {
  20.             string DAPR_STORE_NAME = "statestore";
  21.             while(true) {
  22.                 System.Threading.Thread.Sleep(5000);
  23.                 using var client = new DaprClientBuilder().Build();
  24.                 Random random = new Random();
  25.                 int orderId = random.Next(1,1000);
  26.                 //Using Dapr SDK to save and get state
  27.                 await client.SaveStateAsync(DAPR_STORE_NAME, "order_1", orderId.ToString());
  28.                 await client.SaveStateAsync(DAPR_STORE_NAME, "order_2", orderId.ToString());
  29.                 var result = await client.GetStateAsync<string>(DAPR_STORE_NAME, "order_1");
  30.                 Console.WriteLine("Result after get: " + result);
  31.             }
  32.         }
  33.     }
  34. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 dotnet run
  1. //dependencies
  2. import io.dapr.client.DaprClient;
  3. import io.dapr.client.DaprClientBuilder;
  4. import io.dapr.client.domain.State;
  5. import io.dapr.client.domain.TransactionalStateOperation;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import reactor.core.publisher.Mono;
  10. import java.util.Random;
  11. import java.util.concurrent.TimeUnit;
  13. //code
  14. @SpringBootApplication
  15. public class OrderProcessingServiceApplication {
  17.     private static final Logger log = LoggerFactory.getLogger(OrderProcessingServiceApplication.class);
  19.     private static final String STATE_STORE_NAME = "statestore";
  21.     public static void main(String[] args) throws InterruptedException{
  22.         while(true) {
  23.             TimeUnit.MILLISECONDS.sleep(5000);
  24.             Random random = new Random();
  25.             int orderId = random.nextInt(1000-1) + 1;
  26.             DaprClient client = new DaprClientBuilder().build();
  27.             //Using Dapr SDK to save and get state
  28.             client.saveState(STATE_STORE_NAME, "order_1", Integer.toString(orderId)).block();
  29.             client.saveState(STATE_STORE_NAME, "order_2", Integer.toString(orderId)).block();
  30.             Mono<State<String>> result = client.getState(STATE_STORE_NAME, "order_1", String.class);
  31.             log.info("Result after get" + result);
  32.         }
  33.     }
  35. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 mvn spring-boot:run
  1. #dependencies
  2. import random
  3. from time import sleep    
  4. import requests
  5. import logging
  6. from dapr.clients import DaprClient
  7. from dapr.clients.grpc._state import StateItem
  8. from dapr.clients.grpc._request import TransactionalStateOperation, TransactionOperationType
  10. #code
  11. logging.basicConfig(level = logging.INFO)
  12. DAPR_STORE_NAME = "statestore"
  13. while True:
  14.     sleep(random.randrange(50, 5000) / 1000)
  15.     orderId = random.randint(1, 1000)
  16.     with DaprClient() as client:
  17.         #Using Dapr SDK to save and get state
  18.         client.save_state(DAPR_STORE_NAME, "order_1", str(orderId)) 
  19.         result = client.get_state(DAPR_STORE_NAME, "order_1")
  20.         logging.info('Result after get: ' + result.data.decode('utf-8'))

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 -- python3 OrderProcessingService.py
  1. //dependencies
  2. import (
  3.     "context"
  4.     "log"
  5.     "math/rand"
  6.     "time"
  7.     "strconv"
  8.     dapr "github.com/dapr/go-sdk/client"
  9. )
  11. //code
  12. func main() {
  13.     for i := 0; i < 10; i++ {
  14.         time.Sleep(5000)
  15.         orderId := rand.Intn(1000-1) + 1
  16.         client, err := dapr.NewClient()
  17.         STATE_STORE_NAME := "statestore"
  18.         if err != nil {
  19.             panic(err)
  20.         }
  21.         defer client.Close()
  22.         ctx := context.Background()
  23.         //Using Dapr SDK to save and get state
  24.         if err := client.SaveState(ctx, STATE_STORE_NAME, "order_1", []byte(strconv.Itoa(orderId))); err != nil {
  25.             panic(err)
  26.         }    
  27.         result, err := client.GetState(ctx, STATE_STORE_NAME, "order_2")
  28.         if err != nil {
  29.             panic(err)
  30.         }
  31.         log.Println("Result after get: ")
  32.         log.Println(result)
  33.     }
  34. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 go run OrderProcessingService.go
  1. //dependencies
  2. import { DaprClient, HttpMethod, CommunicationProtocolEnum } from 'dapr-client'; 
  4. //code
  5. const daprHost = "127.0.0.1"; 
  6. var main = function() {
  7.     for(var i=0;i<10;i++) {
  8.         sleep(5000);
  9.         var orderId = Math.floor(Math.random() * (1000 - 1) + 1);
  10.         start(orderId).catch((e) => {
  11.             console.error(e);
  12.             process.exit(1);
  13.         });
  14.     }
  15. }
  17. async function start(orderId) {
  18.     const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT, CommunicationProtocolEnum.HTTP);
  19.     const STATE_STORE_NAME = "statestore";
  20.     //Using Dapr SDK to save and get state
  21.     await client.state.save(STATE_STORE_NAME, [
  22.         {
  23.             key: "order_1",
  24.             value: orderId.toString()
  25.         },
  26.         {
  27.             key: "order_2",
  28.             value: orderId.toString()
  29.         }
  30.     ]);
  31.     var result = await client.state.get(STATE_STORE_NAME, "order_1");
  32.     console.log("Result after get: " + result);
  33. }
  35. function sleep(ms) {
  36.     return new Promise(resolve => setTimeout(resolve, ms));
  37. }
  39. main();

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 npm start

Begin by launching a Dapr sidecar:

  1. dapr run --app-id orderprocessing --dapr-http-port 3601

Then in a separate terminal save a key/value pair into your statestore:

  1. curl -X POST -H "Content-Type: application/json" -d '[{ "key": "order_1", "value": "250"}]' http://localhost:3601/v1.0/state/statestore

Now get the state you just saved:

  1. curl http://localhost:3601/v1.0/state/statestore/order_1

Restart your sidecar and try retrieving state again to observe that state persists separately from the app.

Begin by launching a Dapr sidecar:

  1. dapr --app-id orderprocessing --port 3601 run

Then in a separate terminal save a key/value pair into your statestore:

  1. Invoke-RestMethod -Method Post -ContentType 'application/json' -Body '[{"key": "order_1", "value": "250"}]' -Uri 'http://localhost:3601/v1.0/state/statestore'

Now get the state you just saved:

  1. Invoke-RestMethod -Uri 'http://localhost:3601/v1.0/state/statestore/order_1'

Restart your sidecar and try retrieving state again to observe that state persists separately from the app.

Step 3: Delete state

Below are code examples that leverage Dapr SDKs for deleting the state.

  1. //dependencies
  2. using Dapr.Client;
  4. //code
  5. namespace EventService
  6. {
  7.     class Program
  8.     {
  9.         static async Task Main(string[] args)
  10.         {
  11.             string DAPR_STORE_NAME = "statestore";
  12.             //Using Dapr SDK to delete the state
  13.             using var client = new DaprClientBuilder().Build();
  14.             await client.DeleteStateAsync(DAPR_STORE_NAME, "order_1", cancellationToken: cancellationToken);
  15.         }
  16.     }
  17. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 dotnet run
  1. //dependencies
  2. import io.dapr.client.DaprClient;
  3. import io.dapr.client.DaprClientBuilder;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. //code
  7. @SpringBootApplication
  8. public class OrderProcessingServiceApplication {
  9.     public static void main(String[] args) throws InterruptedException{
  10.         String STATE_STORE_NAME = "statestore";
  12.         //Using Dapr SDK to delete the state
  13.         DaprClient client = new DaprClientBuilder().build();
  14.         String storedEtag = client.getState(STATE_STORE_NAME, "order_1", String.class).block().getEtag();
  15.         client.deleteState(STATE_STORE_NAME, "order_1", storedEtag, null).block();
  16.     }
  17. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 mvn spring-boot:run
  1. #dependencies
  2. from dapr.clients.grpc._request import TransactionalStateOperation, TransactionOperationType
  4. #code
  5. logging.basicConfig(level = logging.INFO)
  6. DAPR_STORE_NAME = "statestore"
  8. #Using Dapr SDK to delete the state
  9. with DaprClient() as client:
  10.     client.delete_state(store_name=DAPR_STORE_NAME, key="order_1")

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 -- python3 OrderProcessingService.py
  1. //dependencies
  2. import (
  3.     "context"
  4.     dapr "github.com/dapr/go-sdk/client"
  6. )
  8. //code
  9. func main() {
  10.     STATE_STORE_NAME := "statestore"
  11.     //Using Dapr SDK to delete the state
  12.     client, err := dapr.NewClient()
  13.     if err != nil {
  14.         panic(err)
  15.     }
  16.     defer client.Close()
  17.     ctx := context.Background()
  19.     if err := client.DeleteState(ctx, STATE_STORE_NAME, "order_1"); err != nil {
  20.         panic(err)
  21.     }
  22. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 go run OrderProcessingService.go
  1. //dependencies
  2. import { DaprClient, HttpMethod, CommunicationProtocolEnum } from 'dapr-client'; 
  4. //code
  5. const daprHost = "127.0.0.1"; 
  6. var main = function() {
  7.     const STATE_STORE_NAME = "statestore";
  8.     //Using Dapr SDK to save and get state
  9.     const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT, CommunicationProtocolEnum.HTTP);
  10.     await client.state.delete(STATE_STORE_NAME, "order_1"); 
  11. }
  13. main();

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 npm start

With the same Dapr instance running from above run:

  1. curl -X DELETE 'http://localhost:3601/v1.0/state/statestore/order_1'

Try getting state again and note that no value is returned.

With the same Dapr instance running from above run:

  1. Invoke-RestMethod -Method Delete -Uri 'http://localhost:3601/v1.0/state/statestore/order_1'

Try getting state again and note that no value is returned.

Step 4: Save and retrieve multiple states

Below are code examples that leverage Dapr SDKs for saving and retrieving multiple states.

  1. //dependencies
  2. import io.dapr.client.DaprClient;
  3. import io.dapr.client.DaprClientBuilder;
  4. import io.dapr.client.domain.State;
  5. import java.util.Arrays;
  7. //code
  8. @SpringBootApplication
  9. public class OrderProcessingServiceApplication {
  11.     private static final Logger log = LoggerFactory.getLogger(OrderProcessingServiceApplication.class);
  13.     public static void main(String[] args) throws InterruptedException{
  14.         String STATE_STORE_NAME = "statestore";
  15.         //Using Dapr SDK to retrieve multiple states
  16.         DaprClient client = new DaprClientBuilder().build();
  17.         Mono<List<State<String>>> resultBulk = client.getBulkState(STATE_STORE_NAME,
  18.         Arrays.asList("order_1", "order_2"), String.class);
  19.     }
  20. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 mvn spring-boot:run
  1. #dependencies
  2. from dapr.clients import DaprClient
  3. from dapr.clients.grpc._state import StateItem
  5. #code
  6. logging.basicConfig(level = logging.INFO)
  7. DAPR_STORE_NAME = "statestore"
  8. orderId = 100
  9. #Using Dapr SDK to save and retrieve multiple states
  10. with DaprClient() as client:
  11.     client.save_bulk_state(store_name=DAPR_STORE_NAME, states=[StateItem(key="order_2", value=str(orderId))])
  12.     result = client.get_bulk_state(store_name=DAPR_STORE_NAME, keys=["order_1", "order_2"], states_metadata={"metakey": "metavalue"}).items
  13.     logging.info('Result after get bulk: ' + str(result))

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 -- python3 OrderProcessingService.py
  1. //dependencies
  2. import { DaprClient, HttpMethod, CommunicationProtocolEnum } from 'dapr-client'; 
  4. //code
  5. const daprHost = "127.0.0.1"; 
  6. var main = function() {
  7.     const STATE_STORE_NAME = "statestore";
  8.     var orderId = 100;
  9.     //Using Dapr SDK to save and retrieve multiple states
  10.     const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT, CommunicationProtocolEnum.HTTP);
  11.     await client.state.save(STATE_STORE_NAME, [
  12.         {
  13.             key: "order_1",
  14.             value: orderId.toString()
  15.         },
  16.         {
  17.             key: "order_2",
  18.             value: orderId.toString()
  19.         }
  20.     ]);
  21.     result = await client.state.getBulk(STATE_STORE_NAME, ["order_1", "order_2"]);
  22. }
  24. main();

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 npm start

With the same Dapr instance running from above save two key/value pairs into your statestore:

  1. curl -X POST -H "Content-Type: application/json" -d '[{ "key": "order_1", "value": "250"}, { "key": "order_2", "value": "550"}]' http://localhost:3601/v1.0/state/statestore

Now get the states you just saved:

  1. curl -X POST -H "Content-Type: application/json" -d '{"keys":["order_1", "order_2"]}' http://localhost:3601/v1.0/state/statestore/bulk

With the same Dapr instance running from above save two key/value pairs into your statestore:

  1. Invoke-RestMethod -Method Post -ContentType 'application/json' -Body '[{ "key": "order_1", "value": "250"}, { "key": "order_2", "value": "550"}]' -Uri 'http://localhost:3601/v1.0/state/statestore'

Now get the states you just saved:

  1. Invoke-RestMethod -Method Post -ContentType 'application/json' -Body '{"keys":["order_1", "order_2"]}' -Uri 'http://localhost:3601/v1.0/state/statestore/bulk'

Step 5: Perform state transactions

Note

State transactions require a state store that supports multi-item transactions. Visit the supported state stores page page for a full list. Note that the default Redis container created in a self-hosted environment supports them.

Below are code examples that leverage Dapr SDKs for performing state transactions.

  1. //dependencies
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Net.Http;
  5. using System.Net.Http.Headers;
  6. using System.Threading.Tasks;
  7. using Dapr.Client;
  8. using Microsoft.AspNetCore.Mvc;
  9. using System.Threading;
  10. using System.Text.Json;
  12. //code
  13. namespace EventService
  14. {
  15.     class Program
  16.     {
  17.         static async Task Main(string[] args)
  18.         {
  19.             string DAPR_STORE_NAME = "statestore";
  20.             while(true) {
  21.                 System.Threading.Thread.Sleep(5000);
  22.                 Random random = new Random();
  23.                 int orderId = random.Next(1,1000);
  24.                 using var client = new DaprClientBuilder().Build();
  25.                 var requests = new List<StateTransactionRequest>()
  26.                 {
  27.                     new StateTransactionRequest("order_3", JsonSerializer.SerializeToUtf8Bytes(orderId.ToString()), StateOperationType.Upsert),
  28.                     new StateTransactionRequest("order_2", null, StateOperationType.Delete)
  29.                 };
  30.                 CancellationTokenSource source = new CancellationTokenSource();
  31.                 CancellationToken cancellationToken = source.Token;
  32.                 //Using Dapr SDK to perform the state transactions
  33.                 await client.ExecuteStateTransactionAsync(DAPR_STORE_NAME, requests, cancellationToken: cancellationToken);
  34.                 Console.WriteLine("Order requested: " + orderId);
  35.                 Console.WriteLine("Result: " + result);
  36.             }
  37.         }
  38.     }
  39. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 dotnet run
  1. //dependencies
  2. import io.dapr.client.DaprClient;
  3. import io.dapr.client.DaprClientBuilder;
  4. import io.dapr.client.domain.State;
  5. import io.dapr.client.domain.TransactionalStateOperation;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import reactor.core.publisher.Mono;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. import java.util.Random;
  13. import java.util.concurrent.TimeUnit;
  15. //code
  16. @SpringBootApplication
  17. public class OrderProcessingServiceApplication {
  19.     private static final Logger log = LoggerFactory.getLogger(OrderProcessingServiceApplication.class);
  21.     private static final String STATE_STORE_NAME = "statestore";
  23.     public static void main(String[] args) throws InterruptedException{
  24.         while(true) {
  25.             TimeUnit.MILLISECONDS.sleep(5000);
  26.             Random random = new Random();
  27.             int orderId = random.nextInt(1000-1) + 1;
  28.             DaprClient client = new DaprClientBuilder().build();
  29.             List<TransactionalStateOperation<?>> operationList = new ArrayList<>();
  30.             operationList.add(new TransactionalStateOperation<>(TransactionalStateOperation.OperationType.UPSERT,
  31.                     new State<>("order_3", Integer.toString(orderId), "")));
  32.             operationList.add(new TransactionalStateOperation<>(TransactionalStateOperation.OperationType.DELETE,
  33.                     new State<>("order_2")));
  34.             //Using Dapr SDK to perform the state transactions
  35.             client.executeStateTransaction(STATE_STORE_NAME, operationList).block();
  36.             log.info("Order requested: " + orderId);
  37.         }
  38.     }
  40. }

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 mvn spring-boot:run
  1. #dependencies
  2. import random
  3. from time import sleep    
  4. import requests
  5. import logging
  6. from dapr.clients import DaprClient
  7. from dapr.clients.grpc._state import StateItem
  8. from dapr.clients.grpc._request import TransactionalStateOperation, TransactionOperationType
  10. #code
  11. logging.basicConfig(level = logging.INFO)    
  12. DAPR_STORE_NAME = "statestore"
  13. while True:
  14.     sleep(random.randrange(50, 5000) / 1000)
  15.     orderId = random.randint(1, 1000)
  16.     with DaprClient() as client:
  17.         #Using Dapr SDK to perform the state transactions
  18.         client.execute_state_transaction(store_name=DAPR_STORE_NAME, operations=[
  19.             TransactionalStateOperation(
  20.                 operation_type=TransactionOperationType.upsert,
  21.                 key="order_3",
  22.                 data=str(orderId)),
  23.             TransactionalStateOperation(key="order_3", data=str(orderId)),
  24.             TransactionalStateOperation(
  25.                 operation_type=TransactionOperationType.delete,
  26.                 key="order_2",
  27.                 data=str(orderId)),
  28.             TransactionalStateOperation(key="order_2", data=str(orderId))
  29.         ])
  31.     client.delete_state(store_name=DAPR_STORE_NAME, key="order_1")
  32.     logging.basicConfig(level = logging.INFO)
  33.     logging.info('Order requested: ' + str(orderId))
  34.     logging.info('Result: ' + str(result))

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 -- python3 OrderProcessingService.py
  1. //dependencies
  2. import { DaprClient, HttpMethod, CommunicationProtocolEnum } from 'dapr-client'; 
  4. //code
  5. const daprHost = "127.0.0.1"; 
  6. var main = function() {
  7.     for(var i=0;i<10;i++) {
  8.         sleep(5000);
  9.         var orderId = Math.floor(Math.random() * (1000 - 1) + 1);
  10.         start(orderId).catch((e) => {
  11.             console.error(e);
  12.             process.exit(1);
  13.         });
  14.     }
  15. }
  17. async function start(orderId) {
  18.     const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT, CommunicationProtocolEnum.HTTP);
  19.     const STATE_STORE_NAME = "statestore";
  20.     //Using Dapr SDK to save and retrieve multiple states
  21.     await client.state.transaction(STATE_STORE_NAME, [
  22.         {
  23.         operation: "upsert",
  24.         request: {
  25.             key: "order_3",
  26.             value: orderId.toString()
  27.         }
  28.         },
  29.         {
  30.         operation: "delete",
  31.         request: {
  32.             key: "order_2"
  33.         }
  34.         }
  35.     ]);
  36. }
  38. function sleep(ms) {
  39.     return new Promise(resolve => setTimeout(resolve, ms));
  40. }
  42. main();

Navigate to the directory containing the above code, then run the following command to launch a Dapr sidecar and run the application:

  1. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 npm start

With the same Dapr instance running from above perform two state transactions:

  1. curl -X POST -H "Content-Type: application/json" -d '{"operations": [{"operation":"upsert", "request": {"key": "order_1", "value": "250"}}, {"operation":"delete", "request": {"key": "order_2"}}]}' http://localhost:3601/v1.0/state/statestore/transaction

Now see the results of your state transactions:

  1. curl -X POST -H "Content-Type: application/json" -d '{"keys":["order_1", "order_2"]}' http://localhost:3601/v1.0/state/statestore/bulk

With the same Dapr instance running from above save two key/value pairs into your statestore:

  1. Invoke-RestMethod -Method Post -ContentType 'application/json' -Body '{"operations": [{"operation":"upsert", "request": {"key": "order_1", "value": "250"}}, {"operation":"delete", "request": {"key": "order_2"}}]}' -Uri 'http://localhost:3601/v1.0/state/statestore'

Now see the results of your state transactions:

  1. Invoke-RestMethod -Method Post -ContentType 'application/json' -Body '{"keys":["order_1", "order_2"]}' -Uri 'http://localhost:3601/v1.0/state/statestore/bulk'

Next steps

Last modified February 18, 2022: Update setup-jetstream.md (#2200) (428d8c2)