The Strat Coordination Framework

Strat is a framework to represent and deploy portable cloud systems. Strat takes simple functions written in languages you know like Javascript and Go and compiles them into event-driven and service-oriented systems running on the serverless cloud. Strat is the first "infrastructure as high-level code" language, and it represents an evolutionary leap over tools like Terraform, CloudFormation, and Serverless Framework. Here's hello world:


service HelloWorld {
  include "Http"

  Http -> "Hello World!"

Then in your terminal (requires npm):

npm install -g stratc
stratc ./ && stratc ./

In existing configuration management tools, you specify infrastructure details directly--"this is a Lambda", "deploy this in a container", "this talks to SQS", etc. Strat exposes a standard library that abstracts over these proprietary services just how NodeJS's fs abstracts over each operating system's file API.

Services as Libraries

Write, extend, and include entire services in your system. Here's how you'd incorporate a GitHub commit webhook inside your system:

service ContinuousIntegration {
  include "./GitHubCommit"

  GitHubCommit { repository: "Stratosphere" } -> "./beginCIBuild.js"

And the GitHubCommit library only uses the Strat standard library, so its 100% portable:

source GitHubCommit {
  //Strat handles setting up ApiGateway, local with ngrok, etc.
  include "Http"
  include "Birth"

  Http { method: "post", path: "Strat/GitHubCommit" } ->

  Birth -> "./registerGitHubWebhook.js"

While the current generation of configuration management extends itself with "plugins", yaml files, and closed source features, Strat places all the power in the community's hands with a robust foreign function interface, a standard library, and powerful inclusion semantics. Authoring a service or source in Strat others can use is as easy as creating a module or library for computation languages.

Better infrastructure than what you're building by hand

Just how language compilers like gcc optimize your code, Strat's compiler optimizes your infrastructure to be:

Portabilty is back

Strat creates a bytecode-esque system artifact (.sa) file that represents your system and its dependencies, then a Strat substrate executes that .sa file to produce running infrastructure. The .sa file format is simple and can be implemented by many different clouds, single machines, and even on-premise datacenters. Today you can run your .sa files locally, on AWS, and on Linux servers.

With Strat, you can write complex, fully featured systems using cutting edge technologies like Lambda without ever having to use a single proprietary API, and without sacrificing local execution and reproducibility.

Like what you see? Continue to the Hello World deep dive or build an N-tier bookstore.