diff --git a/docs/content/concepts/deployment-modes/_index.md b/docs/content/concepts/deployment-modes/_index.md
new file mode 100644
index 0000000..4a6c615
--- /dev/null
+++ b/docs/content/concepts/deployment-modes/_index.md
@@ -0,0 +1,141 @@
+---
+type: "docs"
+title: "Deployment Modes"
+linkTitle: "Deployment Modes"
+weight: 15
+description: >
+ Understand the different ways you can deploy and run Drasi
+related:
+ concepts:
+ - title: "Why Drasi?"
+ url: "/concepts/overview/"
+ howto:
+ - title: "Install Drasi Platform"
+ url: "/how-to-guides/installation/"
+ - title: "Using Drasi Server"
+ url: "/how-to-guides/installation/drasi-server/"
+ - title: "Using drasi-lib"
+ url: "/how-to-guides/installation/drasi-lib/"
+---
+
+## Introduction
+
+Drasi offers flexible deployment options to meet different application needs and infrastructure requirements. Whether you're building a small embedded application, running a standalone service, or deploying a distributed platform on Kubernetes, Drasi adapts to your environment.
+
+## Deployment Modes
+
+Drasi can be deployed in three distinct modes, each optimized for different use cases:
+
+
+
+
+
+
+
+
Drasi Library (drasi-lib)
+
Embed Drasi directly into your Rust applications as a library crate. Perfect for applications that need change processing capabilities without external dependencies.
+
Best for: Embedded systems, single applications, minimal footprint deployments
+
Learn more →
+
+
+
+
+
+
+
+
+
Drasi Server
+
Run Drasi as a standalone server process. Provides a complete change processing service without Kubernetes overhead.
+
Best for: Development environments, single-server deployments, traditional hosting
+
Learn more →
+
+
+
+
+
+
+
+
+
Drasi Platform (Kubernetes)
+
Deploy Drasi as a distributed platform on Kubernetes. Provides scalability, high availability, and enterprise-grade operations.
+
Best for: Production deployments, multi-tenant environments, high-scale applications
+
Learn more →
+
+
+
+
+## Comparison
+
+The following table helps you choose the right deployment mode for your needs:
+
+| Feature | drasi-lib | Drasi Server | Drasi Platform |
+|---------|-----------|--------------|----------------|
+| **Deployment** | Embedded in application | Standalone process | Kubernetes cluster |
+| **Management** | Programmatic API | Command-line/API | CLI + Kubernetes API |
+| **Scaling** | Single instance | Single instance | Horizontal scaling |
+| **Dependencies** | Minimal | Minimal | Kubernetes, Dapr, databases |
+| **Operations** | Application lifecycle | Process management | Kubernetes orchestration |
+| **Use Case** | Embedded applications | Development, simple deployments | Production, enterprise |
+| **Availability** | Single instance | Single instance | High availability |
+| **Multi-tenancy** | Single application | Single server | Multi-tenant capable |
+
+## Choosing a Deployment Mode
+
+### Use drasi-lib when:
+- You're building a Rust application that needs change processing
+- You want to embed Drasi functionality directly in your code
+- You need minimal external dependencies
+- Your application manages its own lifecycle
+- You're building embedded systems or IoT applications
+
+### Use Drasi Server when:
+- You need a standalone change processing service
+- You're developing or testing locally
+- You want to deploy on traditional infrastructure (VMs, bare metal)
+- You don't need Kubernetes orchestration
+- You're running a single-tenant deployment
+
+### Use Drasi Platform when:
+- You're deploying to production at scale
+- You need high availability and fault tolerance
+- You require horizontal scaling capabilities
+- You're already using Kubernetes
+- You need multi-tenant isolation
+- You want enterprise-grade operations and monitoring
+
+## Architecture Differences
+
+While all three deployment modes provide the same core Drasi functionality—{{< term "Source" "Sources" >}}, {{< term "Continuous Query" "Continuous Queries" >}}, and {{< term "Reaction" "Reactions" >}}—the way they're deployed and managed differs:
+
+### drasi-lib Architecture
+The library mode embeds all Drasi components within your application process. Your application code directly interacts with Drasi through Rust APIs, managing Sources, Continuous Queries, and Reactions programmatically.
+
+### Drasi Server Architecture
+The server mode runs Drasi as a single standalone process. You interact with it through a REST API or command-line interface. All components run within the same process, but are managed as a service.
+
+### Drasi Platform Architecture
+The platform mode distributes Drasi components across multiple pods in Kubernetes. This includes separate components for the control plane, query containers, Sources, and Reactions. The platform leverages Kubernetes for orchestration, Dapr for distributed systems patterns, and provides full horizontal scaling capabilities.
+
+## Configuration and Management
+
+Each deployment mode has different configuration and management approaches:
+
+- **drasi-lib**: Configure through Rust code and configuration files
+- **Drasi Server**: Configure through configuration files and command-line arguments
+- **Drasi Platform**: Configure through YAML manifests and the Drasi CLI
+
+## Migration Between Modes
+
+While the three deployment modes share the same core concepts and capabilities, migrating between them requires some adaptation:
+
+- **drasi-lib to Drasi Server**: Requires refactoring programmatic API calls to use the server's REST API or CLI
+- **Drasi Server to Drasi Platform**: Requires packaging your configuration as Kubernetes manifests
+- **Between any modes**: Core query definitions and logic remain the same, only the deployment and management layer changes
+
+## Next Steps
+
+Choose your deployment mode and get started:
+
+- [Get started with drasi-lib](/how-to-guides/installation/drasi-lib/)
+- [Get started with Drasi Server](/how-to-guides/installation/drasi-server/)
+- [Get started with Drasi Platform](/how-to-guides/installation/)
diff --git a/docs/content/concepts/overview/_index.md b/docs/content/concepts/overview/_index.md
index cb53b1f..6e00736 100644
--- a/docs/content/concepts/overview/_index.md
+++ b/docs/content/concepts/overview/_index.md
@@ -10,6 +10,8 @@ related:
- title: "Getting Started with Drasi"
url: "/getting-started/"
concepts:
+ - title: "Deployment Modes"
+ url: "/concepts/deployment-modes/"
- title: "Sources"
url: "/concepts/sources/"
- title: "Continuous Queries"
@@ -30,6 +32,16 @@ Here are some examples of scenarios where Drasi's functionality can be applied t
- Optimizing the delivery of orders to customers when they arrive in a curbside pickup zone.
- Improving infrastructure threat detection by raising alerts when a container with known security threats is deployed to a Kubernetes Cluster.
+## Flexible Deployment
+
+Drasi offers three deployment modes to fit your needs:
+
+- **[Drasi Library (drasi-lib)](/how-to-guides/installation/drasi-lib/)**: Embed Drasi directly in your Rust applications
+- **[Drasi Server](/how-to-guides/installation/drasi-server/)**: Run as a standalone server process
+- **[Drasi Platform](/how-to-guides/installation/)**: Deploy on Kubernetes for production scale
+
+Learn more about choosing the right deployment mode in [Deployment Modes](/concepts/deployment-modes/).
+
## Components
Drasi is built around three simple components: {{< term "Source" "Sources" >}}, {{< term "Continuous Query" "Continuous Queries" >}}, and {{< term "Reaction" "Reactions" >}}. In the simplest scenario, data flows through these components from left to right as shown in the diagram below. But, a single Drasi environment can host many Sources, Continuous Queries, and Reactions, allowing you to connect them together to build scalable Data Change Processing capabilities to power dynamic business solutions. Each of these concepts is discussed in more detail below.
diff --git a/docs/content/getting-started/_index.md b/docs/content/getting-started/_index.md
index 3f50cad..e9cb9e5 100644
--- a/docs/content/getting-started/_index.md
+++ b/docs/content/getting-started/_index.md
@@ -12,6 +12,8 @@ related:
- title: "Writing Single-Source Queries"
url: "/tutorials/write-single-source-continuous-queries/"
concepts:
+ - title: "Deployment Modes"
+ url: "/concepts/deployment-modes/"
- title: "Why Drasi?"
url: "/concepts/overview/"
- title: "Sources"
@@ -32,6 +34,10 @@ related:
url: "/reference/query-language/"
---
+{{% alert color="info" %}}
+This tutorial focuses on getting started with **Drasi Platform on Kubernetes**. If you're interested in other deployment modes, see [Deployment Modes](/concepts/deployment-modes/) for information about Drasi Server and drasi-lib.
+{{% /alert %}}
+
This step-by-step tutorial will help you get Drasi up and running quickly and show you how easy it is to create Sources, Continuous Queries, and Reactions.
After completing this tutorial, which should take around 30 minutes, you will have created a simple end-to-end Drasi-based change-driven solution, and you will have a fully functional Drasi environment suitable for further experimentation on your own. You will then be able to continue to explore the capabilities of the Drasi platform creating [Sources](/how-to-guides/configure-sources/), [Continuous Queries](/how-to-guides/write-continuous-queries/), and [Reactions](/how-to-guides/configure-reactions/).
diff --git a/docs/content/how-to-guides/installation/_index.md b/docs/content/how-to-guides/installation/_index.md
index b9ab1cb..2fdce7e 100644
--- a/docs/content/how-to-guides/installation/_index.md
+++ b/docs/content/how-to-guides/installation/_index.md
@@ -5,15 +5,21 @@ linkTitle: "Install Drasi"
weight: 10
layout: "install_platform_list"
description: >
- Learn how to install Drasi in a variety of Kubernetes environments
+ Learn how to install and deploy Drasi
related:
tutorials:
- title: "Getting Started with Drasi"
url: "/getting-started/"
concepts:
+ - title: "Deployment Modes"
+ url: "/concepts/deployment-modes/"
- title: "Why Drasi?"
url: "/concepts/overview/"
howto:
+ - title: "Using Drasi Server"
+ url: "/how-to-guides/installation/drasi-server/"
+ - title: "Using drasi-lib"
+ url: "/how-to-guides/installation/drasi-lib/"
- title: "Configure Sources"
url: "/how-to-guides/configure-sources/"
- title: "Configure Reactions"
@@ -22,3 +28,54 @@ related:
- title: "CLI Reference"
url: "/reference/command-line-interface/"
---
+
+## Choose Your Deployment Mode
+
+Drasi offers three deployment modes to fit your needs:
+
+
+
+Not sure which deployment mode is right for you? See [Deployment Modes](/concepts/deployment-modes/) for a detailed comparison.
+
+## Drasi Platform (Kubernetes)
+
+The following guides help you install Drasi Platform on various Kubernetes environments:
diff --git a/docs/content/how-to-guides/installation/drasi-lib/_index.md b/docs/content/how-to-guides/installation/drasi-lib/_index.md
new file mode 100644
index 0000000..a64d983
--- /dev/null
+++ b/docs/content/how-to-guides/installation/drasi-lib/_index.md
@@ -0,0 +1,167 @@
+---
+type: "docs"
+title: "Using drasi-lib"
+linkTitle: "Using drasi-lib"
+weight: 5
+description: >
+ Learn how to use drasi-lib to embed Drasi in your Rust applications
+related:
+ concepts:
+ - title: "Deployment Modes"
+ url: "/concepts/deployment-modes/"
+ - title: "Why Drasi?"
+ url: "/concepts/overview/"
+ howto:
+ - title: "Install Drasi Platform"
+ url: "/how-to-guides/installation/"
+ - title: "Using Drasi Server"
+ url: "/how-to-guides/installation/drasi-server/"
+---
+
+{{% alert color="info" %}}
+**Coming Soon**: Documentation for drasi-lib is currently being developed. This page serves as a placeholder for the upcoming content.
+{{% /alert %}}
+
+## Overview
+
+**drasi-lib** is a Rust crate that allows you to embed Drasi's data change processing capabilities directly into your Rust applications. Instead of deploying Drasi as a separate platform or server, you can integrate it as a library dependency, giving you full programmatic control over Sources, Continuous Queries, and Reactions.
+
+## Key Features
+
+- **Embedded Deployment**: Run Drasi within your application process
+- **Rust Native**: First-class Rust API for type-safe integration
+- **Minimal Dependencies**: No external infrastructure required
+- **Programmatic Control**: Configure and manage Drasi entirely through code
+- **Lightweight**: Optimized for embedded systems and resource-constrained environments
+
+## Use Cases
+
+drasi-lib is ideal for:
+
+- **Embedded Applications**: IoT devices, edge computing, and embedded systems
+- **Standalone Services**: Services that need change processing without external dependencies
+- **Testing**: Unit and integration testing of Drasi-based logic
+- **Custom Deployments**: Applications with specific deployment requirements
+- **Microservices**: Services that need their own embedded change processing
+
+## Comparison with Other Deployment Modes
+
+| Feature | drasi-lib | Drasi Server | Drasi Platform |
+|---------|-----------|--------------|----------------|
+| **Integration** | Library dependency | Separate process | Kubernetes deployment |
+| **Language** | Rust API | REST API | CLI + YAML |
+| **Infrastructure** | None required | Single server | Kubernetes cluster |
+| **Scaling** | Application-level | Vertical | Horizontal |
+
+For a detailed comparison of all deployment modes, see [Deployment Modes](/concepts/deployment-modes/).
+
+## Getting Started
+
+{{% alert color="warning" %}}
+This section will be available when drasi-lib is released.
+{{% /alert %}}
+
+The general steps for using drasi-lib will include:
+
+1. **Add Dependency**: Add drasi-lib to your `Cargo.toml`
+2. **Initialize**: Create a Drasi instance in your application
+3. **Configure Sources**: Define your data sources programmatically
+4. **Create Queries**: Set up Continuous Queries
+5. **Set Up Reactions**: Configure how to handle query result changes
+6. **Run**: Start processing changes
+
+## Example Code
+
+{{% alert color="warning" %}}
+Example code will be provided when drasi-lib is released.
+{{% /alert %}}
+
+A basic example will look similar to:
+
+```rust
+// This is a placeholder example - actual API may differ
+use drasi_lib::{Drasi, Source, ContinuousQuery, Reaction};
+
+fn main() -> Result<(), Box
> {
+ // Initialize Drasi
+ let drasi = Drasi::new()?;
+
+ // Configure a source
+ let source = Source::postgres()
+ .host("localhost")
+ .database("mydb")
+ .build()?;
+
+ // Create a continuous query
+ let query = ContinuousQuery::new("my-query")
+ .cypher("MATCH (n:Person) RETURN n")
+ .source(source)
+ .build()?;
+
+ // Set up a reaction
+ let reaction = Reaction::callback(|change| {
+ println!("Change detected: {:?}", change);
+ });
+
+ // Run
+ drasi.run()?;
+
+ Ok(())
+}
+```
+
+## Installation
+
+{{% alert color="warning" %}}
+Installation instructions will be available when drasi-lib is released.
+{{% /alert %}}
+
+Installation will typically involve adding the crate to your `Cargo.toml`:
+
+```toml
+[dependencies]
+drasi-lib = "*" # Actual version will be specified when released
+```
+
+## Prerequisites
+
+When available, drasi-lib will require:
+
+- Rust (version TBD)
+- Supported operating systems (Linux, macOS, Windows)
+- Sufficient system resources for your use case
+
+## Configuration
+
+{{% alert color="warning" %}}
+Configuration documentation will be provided when drasi-lib is released.
+{{% /alert %}}
+
+Configuration will be done programmatically through Rust code, with options for:
+
+- Source connections
+- Query definitions
+- Reaction handlers
+- Runtime settings
+- Logging and observability
+
+## Next Steps
+
+While drasi-lib is being developed, you can:
+
+- Learn about [Drasi concepts](/concepts/)
+- Try [Drasi Platform on Kubernetes](/how-to-guides/installation/)
+- Try [Drasi Server](/how-to-guides/installation/drasi-server/)
+- Read about [Deployment Modes](/concepts/deployment-modes/) to understand when to use drasi-lib
+
+## Stay Updated
+
+To be notified when drasi-lib becomes available:
+
+- Watch the [Drasi GitHub repository](https://github.com/drasi-project)
+- Join the [Drasi Discord community](https://aka.ms/drasidiscord)
+- Follow [@drasi_project on X](https://x.com/drasi_project)
+
+## Contributing
+
+Interested in contributing to drasi-lib development? See the [Contributing Guide](https://github.com/drasi-project/docs/blob/main/CONTRIBUTING.md) for information on how to get involved.
diff --git a/docs/content/how-to-guides/installation/drasi-server/_index.md b/docs/content/how-to-guides/installation/drasi-server/_index.md
new file mode 100644
index 0000000..5d70dce
--- /dev/null
+++ b/docs/content/how-to-guides/installation/drasi-server/_index.md
@@ -0,0 +1,265 @@
+---
+type: "docs"
+title: "Using Drasi Server"
+linkTitle: "Using Drasi Server"
+weight: 6
+description: >
+ Learn how to run Drasi as a standalone server process
+related:
+ concepts:
+ - title: "Deployment Modes"
+ url: "/concepts/deployment-modes/"
+ - title: "Why Drasi?"
+ url: "/concepts/overview/"
+ howto:
+ - title: "Install Drasi Platform"
+ url: "/how-to-guides/installation/"
+ - title: "Using drasi-lib"
+ url: "/how-to-guides/installation/drasi-lib/"
+---
+
+{{% alert color="info" %}}
+**Coming Soon**: Documentation for Drasi Server is currently being developed. This page serves as a placeholder for the upcoming content.
+{{% /alert %}}
+
+## Overview
+
+**Drasi Server** is a standalone server process that provides Drasi's data change processing capabilities without requiring Kubernetes infrastructure. It runs as a single process on traditional infrastructure like virtual machines, bare metal servers, or containers, making it ideal for development environments and simpler deployments.
+
+## Key Features
+
+- **Standalone Process**: Run Drasi as a single server without Kubernetes
+- **Simple Deployment**: Easy to install and configure on any server
+- **REST API**: Manage Sources, Queries, and Reactions via HTTP endpoints
+- **Command-Line Interface**: Built-in CLI for server management
+- **Low Overhead**: Minimal infrastructure requirements
+- **Development-Friendly**: Perfect for local development and testing
+
+## Use Cases
+
+Drasi Server is ideal for:
+
+- **Development Environments**: Local development and testing
+- **Small Deployments**: Single-server installations
+- **Traditional Infrastructure**: VM-based or bare metal deployments
+- **Edge Locations**: Remote sites without Kubernetes
+- **Proof of Concepts**: Quick setup for evaluations
+- **Cost-Sensitive Deployments**: Environments where Kubernetes overhead is undesirable
+
+## Comparison with Other Deployment Modes
+
+| Feature | drasi-lib | Drasi Server | Drasi Platform |
+|---------|-----------|--------------|----------------|
+| **Deployment** | In-process | Standalone server | Kubernetes |
+| **Management** | Code | CLI/REST API | Drasi CLI + kubectl |
+| **Infrastructure** | None | Single server | Cluster |
+| **Best For** | Embedded apps | Development, simple deployments | Production at scale |
+
+For a detailed comparison of all deployment modes, see [Deployment Modes](/concepts/deployment-modes/).
+
+## Getting Started
+
+{{% alert color="warning" %}}
+This section will be available when Drasi Server is released.
+{{% /alert %}}
+
+The general steps for using Drasi Server will include:
+
+1. **Download**: Get the Drasi Server binary or container image
+2. **Install**: Install on your server or local machine
+3. **Start**: Launch the Drasi Server process
+4. **Configure**: Set up Sources, Continuous Queries, and Reactions
+5. **Monitor**: Use built-in monitoring and logging
+
+## Installation
+
+{{% alert color="warning" %}}
+Installation instructions will be available when Drasi Server is released.
+{{% /alert %}}
+
+Installation options will likely include:
+
+### Binary Installation
+
+```bash
+# Example - actual download URL will be provided when released
+# Download the binary
+curl -L https://github.com/drasi-project/drasi/releases/latest/download/drasi-server -o drasi-server
+chmod +x drasi-server
+
+# Run the server
+./drasi-server start
+```
+
+### Docker Installation
+
+```bash
+# Example - actual image location will be provided when released
+# Run as a container
+docker run -d \
+ --name drasi-server \
+ -p 8080:8080 \
+ ghcr.io/drasi-project/drasi-server:latest
+```
+
+### Package Managers
+
+Installation via package managers like apt, yum, brew, or chocolatey may also be supported.
+
+## Prerequisites
+
+When available, Drasi Server will require:
+
+- Supported operating systems (Linux, macOS, Windows)
+- Available network ports (default port TBD)
+- Sufficient system resources (CPU, memory, storage)
+- Optional: Database for state persistence
+
+## Configuration
+
+{{% alert color="warning" %}}
+Configuration documentation will be provided when Drasi Server is released.
+{{% /alert %}}
+
+Configuration will likely be done through:
+
+- **Configuration Files**: YAML or TOML configuration files
+- **Environment Variables**: For runtime settings
+- **Command-Line Flags**: For startup options
+- **REST API**: For dynamic configuration
+
+Example configuration structure:
+
+```yaml
+# Example configuration (actual format TBD)
+server:
+ port: 8080
+ host: 127.0.0.1 # Use 0.0.0.0 to allow external connections (consider firewall rules)
+
+storage:
+ type: sqlite
+ path: /var/lib/drasi/data.db
+
+logging:
+ level: info
+ format: json
+```
+
+## Managing Drasi Server
+
+{{% alert color="warning" %}}
+Management documentation will be provided when Drasi Server is released.
+{{% /alert %}}
+
+### Command-Line Interface
+
+The server will include a CLI for management tasks:
+
+```bash
+# Start the server
+drasi-server start
+
+# Stop the server
+drasi-server stop
+
+# Check status
+drasi-server status
+
+# View logs
+drasi-server logs
+```
+
+### REST API
+
+A REST API will be available for programmatic management:
+
+```bash
+# Create a source (example)
+curl -X POST http://localhost:8080/api/sources \
+ -H "Content-Type: application/json" \
+ -d @source-definition.json
+
+# Create a query
+curl -X POST http://localhost:8080/api/queries \
+ -H "Content-Type: application/json" \
+ -d @query-definition.json
+
+# Create a reaction
+curl -X POST http://localhost:8080/api/reactions \
+ -H "Content-Type: application/json" \
+ -d @reaction-definition.json
+```
+
+## Monitoring and Operations
+
+{{% alert color="warning" %}}
+Operations documentation will be provided when Drasi Server is released.
+{{% /alert %}}
+
+Drasi Server will provide:
+
+- **Health Endpoints**: Check server health and readiness
+- **Metrics**: Prometheus-compatible metrics
+- **Logging**: Structured logging output
+- **Status Dashboard**: Web-based status interface (optional)
+
+## Upgrading
+
+{{% alert color="warning" %}}
+Upgrade documentation will be provided when Drasi Server is released.
+{{% /alert %}}
+
+Upgrade procedures will be documented including:
+
+- Backup procedures
+- Version compatibility
+- Migration steps
+- Rollback procedures
+
+## Architecture
+
+Drasi Server consolidates all Drasi components into a single process:
+
+- **Control Plane**: Manages Sources, Queries, and Reactions
+- **Query Engine**: Evaluates Continuous Queries
+- **Source Connectors**: Connect to data sources
+- **Reaction Handlers**: Execute reactions
+- **Storage**: Persists configuration and state
+
+All components run within a single process, simplifying deployment while maintaining Drasi's core functionality.
+
+## Limitations
+
+As a single-server deployment, Drasi Server has some limitations compared to the Kubernetes platform:
+
+- **Scaling**: No horizontal scaling (vertical scaling only)
+- **High Availability**: Single point of failure
+- **Multi-Tenancy**: Limited isolation compared to Kubernetes
+- **Orchestration**: Manual process management
+
+For production deployments requiring scale and high availability, consider the [Drasi Platform](/how-to-guides/installation/).
+
+## Migration to Drasi Platform
+
+When you're ready to scale beyond a single server, you can migrate to the Drasi Platform on Kubernetes. Core configurations (Sources, Queries, Reactions) can be exported and imported with minimal changes.
+
+## Next Steps
+
+While Drasi Server is being developed, you can:
+
+- Learn about [Drasi concepts](/concepts/)
+- Try [Drasi Platform on Kubernetes](/how-to-guides/installation/)
+- Try [drasi-lib for embedded use](/how-to-guides/installation/drasi-lib/)
+- Read about [Deployment Modes](/concepts/deployment-modes/) to understand when to use Drasi Server
+
+## Stay Updated
+
+To be notified when Drasi Server becomes available:
+
+- Watch the [Drasi GitHub repository](https://github.com/drasi-project)
+- Join the [Drasi Discord community](https://aka.ms/drasidiscord)
+- Follow [@drasi_project on X](https://x.com/drasi_project)
+
+## Contributing
+
+Interested in contributing to Drasi Server development? See the [Contributing Guide](https://github.com/drasi-project/docs/blob/main/CONTRIBUTING.md) for information on how to get involved.