How-To: Invoke services using HTTP

    This article demonstrates how to deploy services each with an unique application ID for other services to discover and call endpoints on them using service invocation over HTTP.

    For a complete sample demonstrating service invocation, walk through the service invocation quickstart.

    Dapr allows you to assign a global, unique ID for your app. This ID encapsulates the state for your application, regardless of the number of instances it may have.

    If your app uses an SSL connection, you can tell Dapr to invoke your app over an insecure SSL connection:

    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 --app-ssl dotnet run
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 --app-ssl dotnet run
    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 mvn spring-boot:run
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 mvn spring-boot:run

    If your app uses an SSL connection, you can tell Dapr to invoke your app over an insecure SSL connection:

    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 --app-ssl mvn spring-boot:run
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 --app-ssl mvn spring-boot:run
    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 -- python3 CheckoutService.py
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 -- python3 OrderProcessingService.py

    If your app uses an SSL connection, you can tell Dapr to invoke your app over an insecure SSL connection:

    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 --app-ssl -- python3 CheckoutService.py
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 --app-ssl -- python3 OrderProcessingService.py
    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 go run CheckoutService.go
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 go run OrderProcessingService.go
    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 npm start
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 npm start

    If your app uses an SSL connection, you can tell Dapr to invoke your app over an insecure SSL connection:

    2. dapr run --app-id checkout --app-port 6002 --dapr-http-port 3602 --dapr-grpc-port 60002 --app-ssl npm start
    4. dapr run --app-id orderprocessing --app-port 6001 --dapr-http-port 3601 --dapr-grpc-port 60001 --app-ssl npm start

    In Kubernetes, set the dapr.io/app-id annotation on your pod:

    1. apiVersion: apps/v1
    2. kind: Deployment
    3. metadata:
    4.   name: <language>-app
    5.   namespace: default
    6.   labels:
    7.     app: <language>-app
    8. spec:
    9.   replicas: 1
    10.   selector:
    11.     matchLabels:
    12.       app: <language>-app
    13.   template:
    14.     metadata:
    15.       labels:
    16.         app: <language>-app
    17.       annotations:
    18.         dapr.io/enabled: "true"
    19.         dapr.io/app-id: "orderprocessingservice"
    20.         dapr.io/app-port: "6001"
    21. ...

    If your app uses an SSL connection, you can tell Dapr to invoke your app over an insecure SSL connection with the app-ssl: "true" annotation (full list )

    To invoke an application using Dapr, you can use the invoke API on any Dapr instance. The sidecar programming model encourages each application to interact with its own instance of Dapr. The Dapr sidecars discover and communicate with one another.

    Below are code examples that leverage Dapr SDKs for service invocation.

    1. //dependencies
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Net.Http;
    5. using System.Net.Http.Headers;
    7. using Dapr.Client;
    8. using Microsoft.AspNetCore.Mvc;
    9. using System.Threading;
    11. //code
    12. namespace EventService
    13. {
    14.     class Program
    15.     {
    16.         static async Task Main(string[] args)
    17.         {
    18.            while(true) {
    19.                 System.Threading.Thread.Sleep(5000);
    20.                 Random random = new Random();
    21.                 int orderId = random.Next(1,1000);
    22.                 CancellationTokenSource source = new CancellationTokenSource();
    23.                 CancellationToken cancellationToken = source.Token;
    24.                 using var client = new DaprClientBuilder().Build();
    25.                 //Using Dapr SDK to invoke a method
    26.                 var result = client.CreateInvokeMethodRequest(HttpMethod.Get, "checkout", "checkout/" + orderId, cancellationToken);
    27.                 await client.InvokeMethodAsync(result);
    28.                 Console.WriteLine("Order requested: " + orderId);
    29.                 Console.WriteLine("Result: " + result);
    30.             }
    31.         }
    32.     }
    33. }
    1. //dependencies
    2. import io.dapr.client.DaprClient;
    3. import io.dapr.client.DaprClientBuilder;
    4. import io.dapr.client.domain.HttpExtension;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.slf4j.Logger;
    7. import org.slf4j.LoggerFactory;
    8. import java.util.Random;
    9. import java.util.concurrent.TimeUnit;
    11. //code
    12. @SpringBootApplication
    13. public class OrderProcessingServiceApplication {
    15.     private static final Logger log = LoggerFactory.getLogger(OrderProcessingServiceApplication.class);
    17.     public static void main(String[] args) throws InterruptedException{
    18.         while(true) {
    19.             TimeUnit.MILLISECONDS.sleep(5000);
    20.             Random random = new Random();
    21.             int orderId = random.nextInt(1000-1) + 1;
    22.             DaprClient daprClient = new DaprClientBuilder().build();
    23.             //Using Dapr SDK to invoke a method
    24.             var result = daprClient.invokeMethod(
    25.                     "checkout",
    26.                     "checkout/" + orderId,
    27.                     null,
    28.                     HttpExtension.GET,
    29.                     String.class
    30.             );
    31.             log.info("Order requested: " + orderId);
    32.         }
    34. }
    1. #dependencies
    2. import random
    3. from time import sleep
    4. import logging
    5. from dapr.clients import DaprClient
    7. #code
    8. logging.basicConfig(level = logging.INFO) 
    9. while True:
    10.     sleep(random.randrange(50, 5000) / 1000)
    11.     orderId = random.randint(1, 1000)
    12.     with DaprClient() as daprClient:
    13.         #Using Dapr SDK to invoke a method
    14.         result = daprClient.invoke_method(
    15.             "checkout",
    16.                f"checkout/{orderId}",
    17.                data=b'',
    18.                http_verb="GET"
    19.         )    
    20.     logging.basicConfig(level = logging.INFO)
    21.     logging.info('Order requested: ' + str(orderId))
    22.     logging.info('Result: ' + str(result))
    1. //dependencies
    2. import { DaprClient, HttpMethod, CommunicationProtocolEnum } from 'dapr-client'; 
    4. //code
    5. const daprHost = "127.0.0.1"; 
    7. var main = function() {
    8.     for(var i=0;i<10;i++) {
    9.         sleep(5000);
    10.         var orderId = Math.floor(Math.random() * (1000 - 1) + 1);
    11.         start(orderId).catch((e) => {
    12.             console.error(e);
    13.             process.exit(1);
    14.         });
    15.     }
    16. }
    18. async function start(orderId) {
    19.     const client = new DaprClient(daprHost, process.env.DAPR_HTTP_PORT, CommunicationProtocolEnum.HTTP);
    20.     //Using Dapr SDK to invoke a method
    21.     const result = await client.invoker.invoke('checkoutservice' , "checkout/" + orderId , HttpMethod.GET);
    22.     console.log("Order requested: " + orderId);
    23.     console.log("Result: " + result);
    24. }
    26. function sleep(ms) {
    27.     return new Promise(resolve => setTimeout(resolve, ms));
    28. }
    30. main();

    To invoke a ‘GET’ endpoint:

    1. curl http://localhost:3602/v1.0/invoke/checkout/method/checkout/100

    To avoid changing URL paths as much as possible, Dapr provides the following ways to call the service invocation API:

    1. Change the address in the URL to localhost:<dapr-http-port>.
    2. Add a dapr-app-id header to specify the ID of the target service, or alternatively pass the ID via HTTP Basic Auth: http://dapr-app-id:<service-id>@localhost:3602/path.
    1. curl http://localhost:3602/v1.0/invoke/checkout/method/checkout/100

    is equivalent to:

    1. curl -H 'dapr-app-id: checkout' 'http://localhost:3602/checkout/100' -X POST

    or:

    1. curl 'http://dapr-app-id:checkout@localhost:3602/checkout/100' -X POST

    Using CLI:

    When running on namespace supported platforms, you include the namespace of the target app in the app ID: checkout.production

    For example, invoking the example service with a namespace would look like:

    See the for more information on namespaces.

    Our example above showed you how to directly invoke a different service running locally or in Kubernetes. Dapr:

    • Outputs metrics, tracing, and logging information,
    • Allows you to visualize a call graph between services and log errors, and
    • Optionally, log the payload body.