Skip to main content

Dapr Runtime

Dapr (Distributed Application Runtime) is an open-source, portable, event-driven runtime that makes it easy to build resilient, stateless and stateful microservices that run on the cloud and edge. Dapr provides a set of building blocks that abstract common distributed systems capabilities into simple, language-agnostic APIs, enabling developers to focus on business logic rather than infrastructure concerns.

  • Build microservices with service-to-service invocation, state management, and pub/sub messaging
  • Orchestrate complex business processes with durable workflows that survive failures and restarts
  • Build intelligent AI agents with durable execution, memory management, and LLM abstraction
  • Connect to any infrastructure component (databases, message brokers, cloud services) through a unified API
  • Deploy anywhere - self-hosted, Kubernetes, or cloud platforms with consistent APIs
  • Write code in any language - Go, Java, JavaScript, .NET, PHP, Python, and more

What is Dapr?​

Dapr is a runtime that helps developers build distributed applications by providing building blocks for common patterns like service invocation, state management, pub/sub messaging, workflows, and more. Instead of writing infrastructure code, developers use Dapr's HTTP or gRPC APIs (or language-specific SDKs) to access these capabilities.

Dapr runs as a sidecar alongside your application, either as a separate process (self-hosted) or as a container (Kubernetes). This sidecar architecture means your application code doesn't need to include any Dapr runtime code, making integration simple and keeping concerns separated.

Hosting Dapr with Diagrid Catalyst

Diagrid Catalyst handles running and managing the Dapr sidecars and control plane for you, so you don't need to manage sidecar deployment, configuration, or lifecycle yourself.

With Catalyst, you can deploy your applications on the hosting platform of your choice—whether that's Kubernetes, cloud platforms, or on-premises—without being locked into a specific infrastructure.

Building Block APIs​

Dapr provides a comprehensive set of building blocks that abstract common distributed systems patterns:

🔌Service Invocation

Discover and securely invoke services with built-in retries, timeouts, and circuit breakers

📨Pub/Sub

Publish and subscribe to events with guaranteed delivery, dead-letter queues, and broker abstraction

💾State Management

Store and retrieve state with transactional operations, TTL, encryption, and querying support

⚙️Workflows

Orchestrate long-running business processes with durable execution, timers, and external events

🤖Actors

Stateful and stateless objects with concurrency, state encapsulation, and lifecycle management

🔐Secrets

Retrieve secrets from cloud and local secret stores securely

⚙️Configuration

Retrieve and subscribe to application configuration from configuration stores

🔒Distributed Lock

Acquire exclusive locks on resources with automatic timeout and release

🔑Cryptography

Encrypt and decrypt messages without exposing keys to applications

⏰Jobs

Schedule jobs at specific times or intervals with durable execution

💬Conversation

Interact with LLMs with prompt caching, PII obfuscation, and provider abstraction

Cross-cutting Capabilities​

Alongside its building blocks, Dapr provides cross-cutting APIs that apply across all building blocks:

  • Resiliency - Define fault tolerance policies with timeouts, retries/back-offs, and circuit breakers
  • Observability - Automatic metrics, logs, and distributed tracing using W3C Trace Context and OpenTelemetry
  • Security - In-transit encryption with mutual TLS, certificate management, and identity via SPIFFE

Dapr Use Cases​

Workflows​

Build stateful workflows that orchestrate complex business processes, handle long-running operations, and guarantee durable execution through automatic checkpointing and recovery.

Learn more about Dapr Workflows →

Key capabilities:

  • Durable execution that survives process restarts and failures
  • Workflow patterns: task chaining, fan-out/fan-in, async HTTP APIs, compensation
  • External events and timers for human-in-the-loop and scheduled operations
  • Multi-application workflows that span different services

AI Agents​

Build intelligent, autonomous AI agents that can interact with external systems, make decisions, and orchestrate complex workflows using durable execution patterns and pluggable infrastructure.

Learn more about AI Agents with Dapr →

Key capabilities:

  • Durable agents that persist execution state across restarts and failures
  • Pluggable memory using any Dapr state store for conversation history
  • Swappable LLM providers through the Conversation API (OpenAI, Azure OpenAI, AWS Bedrock, etc.)
  • Multi-agent workflows combining LLM intelligence with deterministic orchestration

Microservices​

Build resilient microservices with service discovery, state management, and reliable messaging patterns, decoupled from underlying infrastructure across on-premises and cloud environments.

Learn more about building microservices with Dapr →

Key capabilities:

  • Service-to-service communication with automatic discovery and secure mTLS
  • State management with transactional operations and multi-store support
  • Workflow orchestration for complex business processes and saga patterns
  • Job scheduling for periodic tasks and batch operations

Event-Driven Architecture​

Build scalable event-driven applications using a unified messaging API that abstracts away broker complexity and provides guaranteed delivery, content-based routing, and multi-cloud portability.

Learn more about event-driven architecture →

Key capabilities:

  • Asynchronous communication with loose coupling between services
  • At-least-once delivery with dead-letter queues and retries
  • Broker abstraction supporting 20+ message brokers (Kafka, RabbitMQ, Redis, Azure Service Bus, AWS SNS/SQS, etc.)
  • CloudEvents standard for vendor-neutral event structure

Language SDKs​

Dapr offers language-specific SDKs that expose building block functionality through typed APIs:

🐹Go SDK

Client and service SDKs for building Dapr applications in Go

☕Java SDK

Client SDK with Spring Boot integration for Java applications

📜JavaScript SDK

Client and server SDKs for Node.js and browser applications

🔷.NET SDK

Comprehensive SDK with ASP.NET Core integration and actor support

🐍Python SDK

Client SDK with FastAPI and Flask extensions, plus workflow support

Dapr Agents Framework​

Dapr Agents is a Python framework for building intelligent, durable agents powered by LLMs. It provides agent-centric capabilities such as tool calling, memory management, MCP support, and agent orchestration, while leveraging Dapr for durability, observability, and security at scale.

Key features:

  • Durable execution - Agents automatically checkpoint their state, allowing recovery from failures without losing progress or repeating expensive LLM calls
  • Pluggable memory - Store conversation history in any Dapr state store (Redis, PostgreSQL, MongoDB, etc.) for persistent context across interactions
  • Swappable LLM providers - Use the Dapr Conversation API to switch between OpenAI, Azure OpenAI, AWS Bedrock, Google Vertex AI, and more without code changes
  • Multi-agent workflows - Orchestrate multiple agents within deterministic Dapr Workflows, combining LLM intelligence with reliable orchestration
  • Built-in resiliency - Automatic retries, timeouts, and circuit breakers for external systems and LLM APIs
  • Observability - OpenTelemetry tracing and Prometheus metrics out of the box

Dapr Agents integrates seamlessly with Dapr Workflow, enabling you to build complex agentic systems that combine the intelligence of LLMs with the reliability and predictability of workflow orchestration.

Component Model​

Dapr's component model decouples your application code from underlying infrastructure resources, enabling true portability and multi-cloud deployment. Your applications can be deployed on your preferred infrastructure, whether on-premises or in any cloud environment.

Key benefits:

  • Infrastructure portability - Switch between message brokers, databases, secret stores, and other components without modifying application code
  • Multi-cloud deployment - Run the same application code across different cloud providers (AWS, Azure, GCP) or on-premises environments
  • 30+ state stores - Redis, PostgreSQL, MongoDB, Azure Cosmos DB, AWS DynamoDB, and more
  • 20+ pub/sub brokers - Kafka, RabbitMQ, Redis Streams, Azure Service Bus, AWS SNS/SQS, Google Pub/Sub, and more

Sidecar Architecture​

Dapr exposes its HTTP and gRPC APIs as a sidecar architecture, either as a container or as a process, not requiring the application code to include any Dapr runtime code. This makes integration with Dapr easy from other runtimes, as well as providing separation of the application logic for improved supportability.

Hosting Environments​

Dapr can be hosted in three main ways, each with different operational models:

💻Self-Hosted

Run Dapr as a separate sidecar process alongside your application on Windows/Linux/macOS. You manage the Dapr runtime, sidecars, and control plane yourself.

☸️Kubernetes

Deploy Dapr as a sidecar container in Kubernetes pods with automatic injection. You manage the Kubernetes cluster and Dapr control plane.

☁️Diagrid Catalyst

Managed Dapr platform that handles sidecars and control plane operations. Deploy your applications on any platform while Catalyst runs the Dapr infrastructure on a centralized Kubernetes cluster.

  • Self-hosted runs Dapr as a process-based sidecar, ideal for local development and when you want full control over the runtime.
  • Kubernetes uses container-based sidecars with automatic injection, suitable for containerized environments where your application and sidecars will run side-by-side.
  • Diagrid Catalyst provides an alternative where the Catalyst agent manages the Dapr control plane in a centralized cluster, giving you the flexibility to deploy applications on any hosting platform without managing sidecars or the control plane yourself.