Restate Examples

This repository contains various implementation patterns using Restate in Python. These patterns cover several categories of distributed systems challenges:

Communication

• Durable RPC, Idempotency & Concurrency: Ensuring requests are processed exactly-once and managing sequential execution for Virtual Objects.
• (Delayed) Message Queue: Using Restate as a queue to schedule tasks for immediate or future execution.
• Convert Sync Tasks to Async: Transforming long-running synchronous tasks into asynchronous workflows (e.g., via email notifications).

Orchestration Patterns

• Sagas: Managing distributed consistency by tracking and executing undo actions upon failure.
• Stateful Actors and State Machines: Building state machines using Restate Virtual Objects for automatic state persistence.
• Payment State Machines: Advanced tracking of payment processes, including cancellations and consistent processing.

Scheduling

• Scheduling Tasks: Using Restate as a durable scheduler for future tasks.
• Parallelizing Work: Executing multiple tasks in parallel and aggregating results.
• Payment Signals: Handling asynchronous callbacks for slow payment processes (e.g., Stripe).

Event Processing

• Transactional Event Processing: Processing events (e.g., from Kafka) to update downstream systems transactionally.
• Event Enrichment / Joins: Connecting stateful actors to Kafka for data enrichment via RPC.

The Python examples include several implementation patterns for common distributed systems problems:

Communication

• Durable RPC, Idempotency and Concurrency: Ensuring requests execute exactly-once by persisting them.
• (Delayed) Message Queue: Using Restate as a queue to schedule tasks for now or later.
• Convert Sync Tasks to Async: Turning long-running synchronous tasks (like data uploads) into asynchronous ones.

Orchestration patterns

• Sagas: Preserving consistency by tracking undo actions and running them upon failure.
• Stateful Actors and State Machines: Building state machines using Restate Virtual Objects for automatic state persistence.
• Payment State Machines (Advanced): Tracking complex payment processes to ensure consistent processing and cancellations.

Scheduling

• Scheduling Tasks: Using Restate as a scheduler to trigger and execute tasks at a later time.
• Parallelizing Work: Executing a list of tasks in parallel and gathering results.
• Payment Signals (Advanced): Handling asynchronous payment callbacks (e.g., with Stripe).

Event processing

• Transactional Event Processing: Processing events (e.g., from Kafka) to update downstream systems transactionally.
• Event Enrichment / Joins: Connecting stateful functions/actors to Kafka and making them callable over RPC.

The Go basics examples demonstrate four primary building blocks of the Restate platform:

• Durable Execution: Ensures code runs to completion despite failures. It provides automatic retries and recovery of previously finished actions (e.g., ensuring a recurring payment is created before adding a subscription).
• Building Blocks: Durable versions of standard primitives including queues, promises, RPC, state, and timers.
• Virtual Objects: Stateful serverless objects used to manage durable, consistent state and the logic required to manipulate that state.
• Workflows: Durable execution tasks that possess a unique identity. They can be submitted, awaited, signaled, and queried via durable promises (e.g., a multi-step user signup flow).

Detailed API references and implementation patterns for these concepts can be found in the individual source files: part0/durableexecution.go, part1/buildingblocks.go, part2/virtualobjects.go, and part3/workflows.go.

The restatedev/examples repository provides several categories of examples to help you learn and implement Restate in your applications:

• Basics: Small examples demonstrating core building blocks like durable execution and virtual objects.
• Use Cases and Patterns: Specific implementations for common challenges such as webhooks, workflows, and asynchronous task queuing.
• Integrations: Demonstrations of how to connect Restate with other popular tools, technologies, and libraries.
• End-to-End Applications: Full, runnable demo applications (e.g., food ordering or e-commerce sites) typically provided as a docker compose setup.
• Templates: 'Hello World!' project templates for various languages, build systems, and runtimes, designed to provide a production-ready starting point for services or Lambdas.
• Tutorials: Step-by-step guides that build applications while introducing Restate concepts incrementally.