Draft link

Draft is an open source framework for building distributed systems. With the popularity of service-oriented architectures (SOAs) and microservices it seemed fruitful to build a framework that would establish a path to building reliable systems and simplify a complex problem space.

Draft consists of a few core services that will run with your application, a command line tool known as dctl or (draft controller), and some Go modules that can be used to build services.

Core Services link

• Blueprint- A distributed key/value store and service registry for handling service discovery.
• Fuse - A control plane handling routing configuration to services running within Draft systems.
• Catalyst - An event streaming interface for real-time message production and consumption.

Service Patterns link

Each service is built following the microservice chassis pattern. This gives the services (also known as processes) a common and solid foundation to build your application code on. Our primary intent in using the chassis pattern is be able to offload certain reusable concerns from the service without having to rely on additional infrastructure to augment a service (i.e using a sidecar pattern to handle circuit breakers in network traffic). This reduces system complexity and operational overhead.

Additionally, the integration with system dependencies (i.e databases, caches, or additional common libraries/SDKs) is most of the time handled at the chassis level and injected into the application as needed. A primary example of this is RPC servers and clients. The chassis interface exposes an RPCer interface that allows the application service to register the implementation of the RPC service with the chassis which in turn handles registration and port binding. We will discuss the full implementation of this in more detail, but this design enables better testing, system consistency, and a clear separation of concerns.

Services can easily be built using the model-view-controller pattern for each API service definition it implements. A great example of this is blueprint that implements a key/value database interface within the key_value package. Below is an example of what the file structure looks like. We will review the the construction of services in much more detail throughout the documentation.

  blueprint
└── key_value
    ├── controller.go
    ├── model.go
    └── rpc.go # view
├── main.go
├── go.mod
└── go.sum
  

Dependencies link

Draft is designed to minimize the usage of system dependencies as much as possible. Where needed, core functionality is built into Draft components to reduce operational overhead. Additionally, the deployment of a Draft system is not coupled to any one deployment method. Draft systems can be orchestrated using Kubernetes, Nomad, run on bare-metal or deployed with some hybrid approach. It’s up to the operator (you) to determine what orchestration best meets the needs of the system. Over the next few pages we will review the Draft framework and walk you through building an application using Draft.