What is Architect?

Getting started

Overview

Architect is a framework for developing complex, service-oriented applications, empowering developers to collaborate with one another at scale. Through Architect’s blueprint and deploy tools, teams are able to share services in naturally consumable formats and deploy limitlessly complex networks of dependent services with a single command.

Use cases

Automated environment generation

No matter how complex your application is, Architect is able to spin up fresh environments with a single command. With every service in the stack defining it’s own dependencies, Architect is able to map the entire network topology and deploy to any public/private cloud or local development environment without any additional code or configuration required.

Service architecture packaging

Containerization of cloud-native applications has proven to be a great tool for teams to package their work and share with partners and customers, but what happens when the solution to be shared includes a multitude of specialized services? Complex enterprise solutions like this historically demand hands-on expertise from solutions engineers, but with Architect the entire stack can be packaged as a single, deployable unit.

Team collaboration

As organizations grow, they have a tendency to grow isolated from one another making it harder to collaborate and share work. With Architect, teams share a common inter-process communication and deployment standard that lets everyone integrate with each other’s work and spin up fresh environments without the communication hurdles.

Key Concepts

Standardized dependency references

Much like package managers, Architect manages service dependencies through a standard configuration file, architect.json. In this file, developers creating new services can easily specify the names, versions, and locations of peer services they intent to make calls to. Developers always know when their service makes calls to other services, and Architect enables them to share this knowledge to aid with deployment automation and peer integration.

{
  "dependencies": {
    "movie-service": "^1.2.0",
    "identity-service": "2.4.3"
  }
}

Strong interface specification

Inter-process communication at scale is a difficult thing to coordinate and monitor without knowledge of what data can be expected to be passing from one service to another. In order to aid their production engineers and their system automation, companies like Google, Facebook, and Netflix have pioneered and adopted strict specifications like Protocol Buffers, Thrift, and Ribbon respectively.

Architect’s blueprint for service publication leverages protocol buffers and GRPC as a “language-neutral, platform-neutral, extensible machanism for serializing structured data”. With services published using a consistent interface spec, published services can be more easily wired together, and developers are empowered to work across teams and even across companies without friction.

syntax = "proto3";

message RecommendationRequest {
  string user_id = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
}

message RecommendationResponse {
  // ...
}

service MovieService {
  rpc RecommendationsByUserId (RecommendationRequest) returns (RecommendationResponse) {}
}

Deploy-time discovery & enrichment

With a full understanding of a service’s dependencies and the interfaces they use to communicate with one another, Architect is able to automatically map each service’s network of dependencies and deploy them automatically without any additional configuration. When services are run or deployed to cloud environments, Architect starts up the lowest level dependencies first and enriches services that depend on them with the environment-specific location. By continuing this process across the entire dependency stack, Architect is able to run and deploy limitlessly complex systems through a single command!