In this Quickstart, you schedule a batch script to run every 10 seconds using an input Cron binding. The script processes a JSON file and outputs data to a SQL database using the PostgreSQL Dapr binding.
Select your preferred language-specific Dapr SDK before proceeding with the Quickstart.
Pre-requisites
For this example, you will need:
Step 1: Set up the environment
Clone the sample provided in the Quickstarts repo.
git clone https://github.com/dapr/quickstarts.git
Step 2: Run PostgreSQL Docker container locally
Run the PostgreSQL instance locally in a Docker container on your machine. The Quickstart sample includes a Docker Compose file to locally customize, build, run, and initialize the postgres container with a default orders table.
In a terminal window, from the root of the Quickstarts clone directory, navigate to the bindings/db directory.
Run the following command to set up the container:
Verify that the container is running locally.
The output should include:
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
Step 3: Schedule a Cron job and write to the database
In a new terminal window, navigate to the SDK directory.
cd bindings/python/sdk/batch
Install the dependencies:
pip3 install -r requirements.txt
Run the batch-sdk service alongside a Dapr sidecar.
dapr run --app-id batch-sdk --app-port 50051 --resources-path ../../../components -- python3 app.py
Note: Since Python3.exe is not defined in Windows, you may need to use python app.py instead of python3 app.py.
The code inside the process_batch function is executed every 10 seconds (defined in binding-cron.yaml in the components directory). The binding trigger looks for a route called via HTTP POST in your application by the Dapr sidecar.
# Triggered by Dapr input binding
@app.route('/' + cron_binding_name, methods=['POST'])
def process_batch():
The batch-sdk service uses the PostgreSQL output binding defined in the binding-postgresql.yaml component to insert the OrderId, Customer, and Price records into the orders table.
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:
# Insert order using Dapr output binding via 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)
Step 4: View the output of the job
Notice, as specified above, the code invokes the output binding with the OrderId, Customer, and Price as a payload.
Your output binding’s print statement output:
== 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
In a new terminal, verify the same data has been inserted into the database. Navigate to the bindings/db directory.
Run the following to start the interactive psql CLI:
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
At the admin=# prompt, change to the orders table:
At the orders=# prompt, select all rows:
The output should look like this:
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
The Cron binding-cron.yaml file included for this Quickstart contains the following:
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
Note: The metadata section of binding-cron.yaml contains a Cron expression that specifies how often the binding is invoked.
component\binding-postgresql.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
- Initiates the PostgreSQL binding building block
- Connects to PostgreSQL using the settings specified in the
binding-postgresql.yaml file
With the binding-postgresql.yaml component, you can easily swap out the backend database binding without making code changes.
The PostgreSQL binding-postgresql.yaml file included for this Quickstart contains the following:
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
In the YAML file:
spec/type specifies that PostgreSQL is used for this binding.spec/metadata defines the connection to the PostgreSQL instance used by the component.
Pre-requisites
For this example, you will need:
Step 1: Set up the environment
Clone the sample provided in the Quickstarts repo.
git clone https://github.com/dapr/quickstarts.git
Step 2: Run PostgreSQL Docker container locally
Run the PostgreSQL instance locally in a Docker container on your machine. The Quickstart sample includes a Docker Compose file to locally customize, build, run, and initialize the postgres container with a default orders table.
In a terminal window, from the root of the Quickstarts clone directory, navigate to the bindings/db directory.
Run the following command to set up the container:
Verify that the container is running locally.
The output should include:
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
Step 3: Schedule a Cron job and write to the database
In a new terminal window, navigate to the SDK directory.
cd bindings/javascript/sdk/batch
Install the dependencies:
Run the batch-sdk service alongside a Dapr sidecar.
dapr run --app-id batch-sdk --app-port 5002 --dapr-http-port 3500 --resources-path ../../../components -- node index.js
The code inside the process_batch function is executed every 10 seconds (defined in binding-cron.yaml in the components directory). The binding trigger looks for a route called via HTTP POST in your application by the Dapr sidecar.
async function start() {
await server.binding.receive(cronBindingName,processBatch);
await server.start();
}
The batch-sdk service uses the PostgreSQL output binding defined in the binding-postgresql.yaml component to insert the OrderId, Customer, and Price records into the orders table.
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;
}
Step 4: View the output of the job
Notice, as specified above, the code invokes the output binding with the OrderId, Customer, and Price as a payload.
Your output binding’s print statement output:
== 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)
In a new terminal, verify the same data has been inserted into the database. Navigate to the bindings/db directory.
Run the following to start the interactive Postgres CLI:
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
At the admin=# prompt, change to the orders table:
At the orders=# prompt, select all rows:
The output should look like this:
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
The Cron binding-cron.yaml file included for this Quickstart contains the following:
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
Note: The metadata section of binding-cron.yaml contains a Cron expression that specifies how often the binding is invoked.
component\binding-postgresql.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
- Initiates the PostgreSQL binding building block
- Connects to PostgreSQL using the settings specified in the
binding-postgresql.yaml file
With the binding-postgresql.yaml component, you can easily swap out the backend database binding without making code changes.
The PostgreSQL binding-postgresql.yaml file included for this Quickstart contains the following:
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
In the YAML file:
spec/type specifies that PostgreSQL is used for this binding.spec/metadata defines the connection to the PostgreSQL instance used by the component.
Pre-requisites
For this example, you will need:
NOTE: .NET 6 is the minimally supported version of .NET for the Dapr .NET SDK packages in this release. Only .NET 8 and .NET 9
will be supported in Dapr v1.16 and later releases.
Step 1: Set up the environment
Clone the sample provided in the Quickstarts repo.
git clone https://github.com/dapr/quickstarts.git
Step 2: Run PostgreSQL Docker container locally
Run the PostgreSQL instance locally in a Docker container on your machine. The Quickstart sample includes a Docker Compose file to locally customize, build, run, and initialize the postgres container with a default orders table.
In a terminal window, from the root of the Quickstarts clone directory, navigate to the bindings/db directory.
Run the following command to set up the container:
Verify that the container is running locally.
The output should include:
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
Step 3: Schedule a Cron job and write to the database
In a new terminal window, navigate to the SDK directory.
cd bindings/csharp/sdk/batch
Install the dependencies:
dotnet restore
dotnet build batch.csproj
Run the batch-sdk service alongside a Dapr sidecar.
dapr run --app-id batch-sdk --app-port 7002 --resources-path ../../../components -- dotnet run
The code inside the process_batch function is executed every 10 seconds (defined in binding-cron.yaml in the components directory). The binding trigger looks for a route called via HTTP POST in your application by the Dapr sidecar.
app.MapPost("/" + cronBindingName, async () => {
// ...
});
The batch-sdk service uses the PostgreSQL output binding defined in the binding-postgresql.yaml component to insert the OrderId, Customer, and Price records into the orders table.
// ...
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}
};
// ...
}
// Insert order using Dapr output binding via Dapr Client SDK
await client.InvokeBindingAsync(bindingName: sqlBindingName, operation: "exec", data: "", metadata: command);
Step 4: View the output of the job
Notice, as specified above, the code invokes the output binding with the OrderId, Customer, and Price as a payload.
Your output binding’s print statement output:
== 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
In a new terminal, verify the same data has been inserted into the database. Navigate to the bindings/db directory.
Run the following to start the interactive Postgres CLI:
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
At the admin=# prompt, change to the orders table:
At the orders=# prompt, select all rows:
The output should look like this:
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
The Cron binding-cron.yaml file included for this Quickstart contains the following:
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
Note: The metadata section of binding-cron.yaml contains a Cron expression that specifies how often the binding is invoked.
component\binding-postgresql.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
- Initiates the PostgreSQL binding building block
- Connects to PostgreSQL using the settings specified in the
binding-postgresql.yaml file
With the binding-postgresql.yaml component, you can easily swap out the backend database binding without making code changes.
The PostgreSQL binding-postgresql.yaml file included for this Quickstart contains the following:
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
In the YAML file:
spec/type specifies that PostgreSQL is used for this binding.spec/metadata defines the connection to the PostgreSQL instance used by the component.
Pre-requisites
For this example, you will need:
Step 1: Set up the environment
Clone the sample provided in the Quickstarts repo.
git clone https://github.com/dapr/quickstarts.git
Step 2: Run PostgreSQL Docker container locally
Run the PostgreSQL instance locally in a Docker container on your machine. The Quickstart sample includes a Docker Compose file to locally customize, build, run, and initialize the postgres container with a default orders table.
In a terminal window, from the root of the Quickstarts clone directory, navigate to the bindings/db directory.
Run the following command to set up the container:
Verify that the container is running locally.
The output should include:
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
Step 3: Schedule a Cron job and write to the database
In a new terminal window, navigate to the SDK directory.
cd bindings/java/sdk/batch
Install the dependencies:
Run the batch-sdk service alongside a Dapr sidecar.
dapr run --app-id batch-sdk --app-port 8080 --resources-path ../../../components -- java -jar target/BatchProcessingService-0.0.1-SNAPSHOT.jar
The code inside the process_batch function is executed every 10 seconds (defined in binding-cron.yaml in the components directory). The binding trigger looks for a route called via HTTP POST in your application by the Dapr sidecar.
@PostMapping(path = cronBindingPath, consumes = MediaType.ALL_VALUE)
public ResponseEntity<String> processBatch() throws IOException, Exception
The batch-sdk service uses the PostgreSQL output binding defined in the binding-postgresql.yaml component to insert the OrderId, Customer, and Price records into the orders table.
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);
// Invoke sql output binding using Dapr SDK
client.invokeBinding(sqlBindingName, "exec", null, metadata).block();
}
logger.info("Finished processing batch");
return ResponseEntity.ok("Finished processing batch");
}
Step 4: View the output of the job
Notice, as specified above, the code invokes the output binding with the OrderId, Customer, and Price as a payload.
Your output binding’s print statement output:
== 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
In a new terminal, verify the same data has been inserted into the database. Navigate to the bindings/db directory.
Run the following to start the interactive Postgres CLI:
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
At the admin=# prompt, change to the orders table:
At the orders=# prompt, select all rows:
The output should look like this:
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
The Cron binding-cron.yaml file included for this Quickstart contains the following:
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
Note: The metadata section of binding-cron.yaml contains a Cron expression that specifies how often the binding is invoked.
component\binding-postgresql.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
- Initiates the PostgreSQL binding building block
- Connects to PostgreSQL using the settings specified in the
binding-postgresql.yaml file
With the binding-postgresql.yaml component, you can easily swap out the backend database binding without making code changes.
The PostgreSQL binding-postgresql.yaml file included for this Quickstart contains the following:
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
In the YAML file:
spec/type specifies that PostgreSQL is used for this binding.spec/metadata defines the connection to the PostgreSQL instance used by the component.
Pre-requisites
For this example, you will need:
Step 1: Set up the environment
Clone the sample provided in the Quickstarts repo.
git clone https://github.com/dapr/quickstarts.git
Step 2: Run PostgreSQL Docker container locally
Run the PostgreSQL instance locally in a Docker container on your machine. The Quickstart sample includes a Docker Compose file to locally customize, build, run, and initialize the postgres container with a default orders table.
In a terminal window, from the root of the Quickstarts clone directory, navigate to the bindings/db directory.
Run the following command to set up the container:
Verify that the container is running locally.
The output should include:
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
Step 3: Schedule a Cron job and write to the database
In a new terminal window, navigate to the SDK directory.
Install the dependencies:
Run the batch-sdk service alongside a Dapr sidecar.
dapr run --app-id batch-sdk --app-port 6002 --dapr-http-port 3502 --dapr-grpc-port 60002 --resources-path ../../../components -- go run .
The code inside the process_batch function is executed every 10 seconds (defined in binding-cron.yaml in the components directory). The binding trigger looks for a route called via HTTP POST in your application by the Dapr sidecar.
// Triggered by Dapr input binding
r.HandleFunc("/"+cronBindingName, processBatch).Methods("POST")
The batch-sdk service uses the PostgreSQL output binding defined in the binding-postgresql.yaml component to insert the OrderId, Customer, and Price records into the orders table.
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)
// Insert order using Dapr output binding via 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
}
Step 4: View the output of the job
Notice, as specified above, the code invokes the output binding with the OrderId, Customer, and Price as a payload.
Your output binding’s print statement output:
== 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)
In a new terminal, verify the same data has been inserted into the database. Navigate to the bindings/db directory.
Run the following to start the interactive Postgres CLI:
docker exec -i -t postgres psql --username postgres -p 5432 -h localhost --no-password
At the admin=# prompt, change to the orders table:
At the orders=# prompt, select all rows:
The output should look like this:
orderid | customer | price
---------+------------+--------
1 | John Smith | 100.32
2 | Jane Bond | 15.4
3 | Tony James | 35.56
components\binding-cron.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
The Cron binding-cron.yaml file included for this Quickstart contains the following:
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
Note: The metadata section of binding-cron.yaml contains a Cron expression that specifies how often the binding is invoked.
component\binding-postgresql.yaml component file
When you execute the dapr run command and specify the component path, the Dapr sidecar:
- Initiates the PostgreSQL binding building block
- Connects to PostgreSQL using the settings specified in the
binding-postgresql.yaml file
With the binding-postgresql.yaml component, you can easily swap out the backend database binding without making code changes.
The PostgreSQL binding-postgresql.yaml file included for this Quickstart contains the following:
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
In the YAML file:
spec/type specifies that PostgreSQL is used for this binding.spec/metadata defines the connection to the PostgreSQL instance used by the component.
We’re continuously working to improve our Quickstart examples and value your feedback. Did you find this quickstart helpful? Do you have suggestions for improvement?
