Developed by the European Project-COLA under grant agreement No 731574

Features:

Automated scaling on the level of application

MiCADOscale scales applications on both levels. The level of the virtual machine, as well as the level of the container.

Dashboard for monitoring

MiCADOscale offers an integrated, secured Dashboard with various monitoring options. The Dashboard can be used to track custom inquiries.

Multiple cloud support

MiCADOscale supports scalable applications on various cloud infrastructures like: EC2, OpenStack, CloudSigma & Cloudbroker

Secure distributed systems

Secure the different containers in your distributed systems via Zorp's proxy firewall.

Generic

MiCADOscale is a generic framework, capable to switch some of it's core-components. Instead of using Docker-Swarm, you could also modify MiCADOscale to utilise Kubernetes.

Highly customizable scaling policies

Scaling policies can be defined specifically for the requirements of your applications.

What is MiCADOscale?

The generic plugin framework MiCADOscale (Developed by the members of Project-COLA) supports the optimal and secure deployment of scalable cloud applications.

Almost every IaaS provider offers scalability and elasticity, but most existing applications will not make the most of these features automatically without drastically changing their source code. Current orchestration solutions usually reach not directly into the level of the application itself. For this reason, the scaling logic must be implemented deeply within the application.

MiCADOscale manages the orchestration at the application level by scaling VMs and their included Docker containers based on the resources currently required. MiCADOscale is provided through an Ansible playbook to reduce the configuration time.

Once the core environment has been installed and put into operation, every aspect of your future applications can be tracked with the MiCADOscale-Dashboard, and the logs of the MiCADOscale master node are monitored and logged.

Get MiCADOscale:

MiCADOscale is managed through GitHub.

MiCADOscale is designed for Debian-Linux machines. We recommend using Ubuntu 16.04 & up. To install the latest version of MiCADOscale, please use the detailed documentation.

If you want to tell us your opinion, please use our contact form.

We would also like to inform you, that we are currently running the first open-beta of MiCADOscale. We would be very pleased if you want to participate. Officially registered participants have the chance to win one of 3x Udemy.com coupons, each worth €20. The open-beta will be running until the mid of December this year.

How it works?:

By deploying MiCADOscale, the MiCADOscale-Masternode will be started (instantiated). This node can be deployed on a local or remote machine in the cloud. The Masternode contains all core components for scaling your application in production. It will organize and manage the deployment process of workers in your application cluster and also perform as the server for the MiCADOscale Dashboard.

Most of MiCADOscale's core-components are interchangable. This means, you could - for example - swap Docker-Swarm for Kubernetes to fit your specific usecase.

The package consists of:

Occopus

Docker Swarm

Prometheus

Submitter

Policy Keeper

Multicloud support:

MiCADOscale is able to operate on several target clouds. Currently supported infrastructures for MiCADOscale are:

  1. Amazon AWS EC2
  2. OpenStack
  3. CloudSigma
  4. CloudBroker Platform

Application description:
To deploy an application with MiCADOscale, you will need to specify a detailed description of your application for the MiCADOscale-Masternode. MiCADOscale utilises TOSCA-based description files called "ADT's" (Application Description Templates). These ADT's are split in 4 parts and will describe the the specification of the interconnected container's and the virtual machines, as well as the scaling logic for the application. ADT's are written in JSON-format, so you have to check their integrity carefully before using them.

Structure of an ADT

tosca_definitions_version: tosca_simple_yaml_1_0

imports:
  - https://raw.githubusercontent.com/micado-scale/tosca/v0.6.0/micado_types.yaml

repositories:
  docker_hub: https://hub.docker.com/

topology_template:
  node_templates:
    YOUR_DOCKER_SERVICE:
      type: tosca.nodes.MiCADO.Container.Application.Docker
      properties:
        ...
      artifacts:
        ...
    ...
    YOUR_OTHER_DOCKER_SERVICE:
      type: tosca.nodes.MiCADO.Container.Application.Docker
      properties:
        ...
      artifacts:
        ...
    YOUR_DOCKER_NETWORK:
      type: tosca.nodes.MiCADO.network.Network.Docker
      properties:
        ...

    YOUR_VIRTUAL_MACHINE:
      type: tosca.nodes.MiCADO.Occopus..Compute
      properties:
        cloud:
          interface_cloud: ...
          endpoint_cloud: ...
      capabilities:
        host:
          properties:
            ...

  policies:
  - scalability:
    type: tosca.policies.Scaling.MiCADO
    targets: [ YOUR_VIRTUAL_MACHINE ]
    properties:
      ...
  - scalability:
    type: tosca.policies.Scaling.MiCADO
    targets: [ YOUR_DOCKER_SERVICE ]
    properties:
      ...
  - scalability:
    type: tosca.policies.Scaling.MiCADO
    targets: [ YOUR_OTHER_DOCKER_SERVICE ]
    properties:
      ...

MiCADOscale in production:

Once an ADT is submitted to the MiCADO-Submitter within the MiCADOscale-Master node, it will automatically download the needed packages, configure the networking relations and initiate the minimum required Worker nodes for your application.

If Prometheus detects an alert based on your scaling logic, it will notify Swarm or Occopus to scale up the Containers/VMs to your specified limit. After the detected peak is over, another alert will be triggered to scale your application down to save costs.