Gilliam - A micro services platform

Micro Service Architectures

In the words of James Hughes: Micro Service Architecture is an architectural concept that aims to decouple a solution by decomposing functionality into discrete services. Think of it as applying many of the principles of SOLID at an architectural level, instead of classes you've got services.

Gilliam's goal is to make it easier to develop, deploy and scale these systems. It does that by minimizing differences between development and production environments, bundling of dependencies with the service at build time, lightweight virtualization and service isolation using Docker.

Built for 12 factor apps

The twelve-factor methodology is a methodology for building small services that lend themselves to horizontal scaling. Gilliam uses Heroku buildpacks that takes a 12 factor app and bundles it with all its dependencies into an image that can later be deployed.

Services are defined in a gilliam.yml file living in the root of your code tree:

processes:
  api:
    script: bin/api
    ports:
      - 80
  _worker:
    script: bin/worker
auxiliary:
  _store:
    type: etcd

Simple command-line client

Gilliam is controlled from a command-line tool simply called gilliam. For example, to build a new release and migreate all running instances to that release, just run: all instances to the new release

$ gilliam deploy
...
release 12

To create or destroy instances for a release, just run:

$ gilliam scale -r12 api=10

Built for RESTful APIs

Most components of Gilliam talk HTTP and expose RESTful APIs. It is expected that your application and services will do the same.

$ gilliam route api.myapp.com/user/{user} api.user.service/{user}

The route command exposes an internal service endpoint to the internet. Using variables in the route it is possible to rewrite the URLs so that it fits your internal scheme.

Promotes best practices!

By having the services run in isolated, resource constrained environments Gilliam promotes small stateless services that lend themselves to horizontal scaling.

Each service instance will get a limited amount of CPU and memory. If more resources are needed to meet the demand you need to scale up the number of service instances.

Simple and decoupled

Gilliam is composed of a small set of losely coupled components. Most components expose a simple RESTful API over HTTP that serves up JSON.

The core components are written in Python, using gevent, Routes and WebOb.

Gilliam - A platform for micro services.