Join the waitlist for Restate Cloud Get access

Restate is durable async/await for...

Lambda Workflows as Code

  • Workflows as sequential code + RPC
  • No more JSON/YAML + many Lambdas
  • Stellar local dev & debugging experience
  • Long-lived transactional state across workflows
  • Reliable timers & schedulers

Transactional RPC Handlers

  • Idempotency and partial progress recovery
  • Program with simple request-response
  • Executes like async event handlers
  • Full observability
  • Transactional state

Event Processing with Kafka

  • Event handlers as durable functions
  • Consistent dual-/multi writes
  • Delaying events
  • No head-of-line waiting on slow events
  • Durable side effects
  • Flexible routing/fan-out

A bedrock for robust applications

Resiliency & consistency

Durable execution retries on transient failures and recovers partial progress.

Transactional state

Embedded K/V state that commits updates atomically with durable execution progress.

Multi-language

Typescript, Java, and more languages coming

Observability

Built in OTel tracing for services and RPCs.

Robust building blocks

Reliable messaging, durable RPCs, transactional K/V store, durable timers, …

1

Get started

TypeScript Java

1. Develop a service:

npx -y @restatedev/create-app@latest && cd restate-node-template

2. Run your service:

npm install && npm run build && npm run app

3. Launch Restate:

docker run --name restate_dev --rm -p 8080:8080 -p 9070:9070 -p 9071:9071 --add-host=host.docker.internal:host-gateway docker.io/restatedev/restate:latest

4. Register your service:

curl localhost:9070/deployments  -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:9080"}'

5. Send a request:

curl localhost:8080/myservice/hello -H 'content-type: application/json' -d '{"request": "Restate"}'
2

Get inspired!

Restate’s flexible SDKs allows you to implement a large set of useful patterns in a few lines of code.


// the request router for the target service
const callee = restate.router({
  call: async (ctx: restate.RpcContext, request: { arg: string }) => {
    // this will be reliably invoked via a durable event from the caller
  }
});

// defines the logical location and the type signature
const calleeApi = { path: "callee" } as restate.ServiceApi<typeof callee>

// invoke from another Restate-backed service
const result = await ctx.rpc(calleeApi).call("hello " + request);

// invoke (or re-attach) with an external client
`curl http://<restate>/callee/call --json '{"request": {"arg": "..."}}' -H 'idempotency-key: <key>'`
                        

How does it work?

Restate implements low-latency durable execution with a partitioned command log.

The Restate Runtime pushes invocations to services and functions, journals the execution, and handles retries and failover. Via the journal, functions can recover partial progress after failures or actively suspend when waiting.

Restate stores long-lived k/v state for functions and pushes relevant state together with invocations.

State

cartService: Joe - cart=[]

Journals
3

Deploy anywhere

Restate comes as a single binary that runs without any dependencies. It runs as well on your laptop as it does in the cloud.

Restate is built for modern cloud architectures and works seamlessly with services standalone, on FaaS (AWS Lambda), and as scale-out deployments on container engines like Kubernetes.

Open-source Restate

  • Self-contained single binary
  • BSL-licensed
  • Currently public beta

Restate Cloud

  • Fully managed service
  • Early access version
  • Join the waitlist
4

Observe everything

Detailed insight in execution progress and state across services

Generate OpenTelemetry traces and call trees for services, without any code or configuration.

Restate's unique way of managing inter-service communication and durable execution together means that it can generate detailed observability data right out of the box.

To the docs

Latest news

Solving durable execution’s immutability problem

Solving durable execution’s immutability problem

Posted February 2, 2024 by Jack Kleeman ‐ 8 min read

Code that sleeps for a month

Posted February 2, 2024 by Jack Kleeman ‐ 9 min read

Graceful cancellations: How to keep your application and workflow state consistent 💪

Graceful cancellations: How to keep your application and workflow state consistent 💪

Posted January 24, 2024 by Till Rohrmann ‐ 5 min read

Ready to get started?

Restate is in beta

Try out the preview release of Restate’s managed cloud deployment:

> Get access

Want to get updates on releases
and other news?

> Subscribe