MK

Tosca | Heat | Cloudify | Mist.io

This is the my way how to deep dive into new automated and containerized world. Firstly we must start with new standard called Tosca. This standard is under heavy development and is ideal candidate for near future. I’m not sure, but I think that this standard was developed under Cloudify project, which is engine for creating deployments from tosca blueprints which support workflow exceution, plugins and other cool stuff. Tosca was separed from cloudify and now is presented as Aria Tosca. In Openstack world was started developing of integration to Heat engine which is called as Tosca Heat Translator. This tool gets the tosca blueprint and then maps Heat resources to Tosca stuff and render valid Heat Template in .hot format which is consumed by Heat Engine.

Aria Tosca

ARIA(Agile Reference Implementation of Automation) is an open, light, CLI-driven library of orchestration tools that other open projects can consume to easily build TOSCA-based orchestration solutions.

PLUGIN BASED ARCHITECTURE

ARIA Plugins mechanism allows ARIA to model robust application blueprints: plugins introduce new node types for modeling and are responsible for interacting with APIs and implementing modeled applications.

CUSTOMIZABLE NODE TYPES

ARIA follows the TOSCA DSL modeling standards, it supports inheritance and other characteristics of an object oriented language, allows to customize and create new node types for modelling.

TOPOLOGY

Describe application topologies in a declerative YAML DSL, this creates a graph of application components, their relationships and properites.

LIFECYCLE AND WORKFLOW OPERATIONS

Define application lifecycle interfaces, workflows and execute it’s implementation operations, you can use the build-in workdlows to install and uninstall, and assign their lifecycle intefaces, or create new custom ones.

COMMAND LINE INTERFACE

Orchestration application blueprints via simple to use command line interface.
[aria@orchestrator ~]$ aria init -p blueprint.yaml --install-plugins
[aria@orchestrator ~]$ aria execute -w install

LIBRARY

Integrate TOSCA orchestration capabilities into your existing offering via the ARIA integration library.
from aria_cli import common
from aria_cli.commands import init as aria
from aria_core import blueprints
from aria_core import utils
from aria_core import logger
from aria_core import workflows

Tosca Heat Translator

Why Heat ? For Openstack users is Heat the main cloud orchestrator which takes templates with parameters and make infrastructure from them. This basic concept could has different implementation like a Murano engine was first engine which makes new layer on top templates and inputs. This layer support creating and managing deployed environments. This means you must have UI for end users which can simple create complex infrastructure from templates with mininum requirements.

Basically Murano creates and store data about environments and support calling actions/workflows on them. Murano has own DSL and package format which is similiar to cloudify blueprints. You can define VMs with custom actions/workflows which generates Heat template which is deployed as Heat Stack. All operations are done with Murano Agent, this agent must lives in the VM, infrastructure’s changes are made as Stack Update action, which are little tricky now i think.

We are happy, that OpenStack follows Tosca standard and implements Tosca - Heat translator which supports writing templates in a one format and then use it with popular cloud orchestrators like a Heat or Cloudify.

git clone https://github.com/openstack/heat-translator
cd heat-translator
sudo python setup.py install
sudo pip install tosca-parser
python heat_translator.py --template-file /home/openstack/heat-translator/translator/tests/data/tosca_helloworld.yaml --template-type tosca

Follow bunch of complex examples

Cloudify

Now if we known what the Tosca standard is and why is useful we can start with Cloudify, which is simple app written in Python. Cloudify is decomposed to some roles where manager is core of them. These roles uses some 3rd party tools such as RabbitMQ, Rieman, MongoDB, .. Manager is build on top of Celery workers which uses RabbitMQ. See the big picture of Cloudify Manager.

The cloud orchestration service is based on Cloudify, the open-source, TOSCA-based orchestration platform. The service is similar to AWS’ OpsWorks but is designed for heterogeneous infrastructure. This means you can create a single, reusable template to provision the same application across different cloud providers, data centers, or colo environments.

Move your cursor to the blocks and check screenshoft from cloudify manager.

Mist.io

Mist.io is a software as a service that aims to make cloud management simple and help users free themselves from vendor and complexity lock-in. It offers management, provisioning,  orchestration, monitoring and automation for servers across public and private clouds, Docker containers and KVM hypervisors. It emits actionable alerts so users can address operational issues from anywhere, using any web device. 

The UI and API are released under an open source license for standalone installations. They can optionally connect to the service to provide monitoring and automation.

Combine Cloud Orchestration with other Mist.io features such as monitoring, scheduling, RBAC, and/or APIs, to create automated and dynamic workflows and policies that respond to system events in real time.

What is Mist.io trying to solve

The modern computing landscape can include public or private clouds, Docker containers and bare metal servers. They are usually combined in hybrid setups and although the management needs are common there are different toolsets for each one. This adds a lot of complexity and management overhead. Users have to either adopt one vendor and lock themselves in or stick to complexity and slow down infrastructure operations.

Mist.io provides a single UI and API for infrastructure and application management. From creating servers and deploying applications, to monitoring system uptime and performance metric or alerting and automating responses. Regardless of where the servers are hosted -locally, on a public or private cloud, a KVM hypervisor or a Docker engine-, Mist.io offers a unified dashboard that reduces UI fragmentation and eases management.

Mist.io is not only offered as  SaaS but also as an open source software component for standalone installations, so that organizations and engineers can manage their infrastructure internally.

The open source component can connect to the Mist.io service for monitoring. Currently it is lacking some functionality offered by the SaaS, namely the logs section and the ability to create and run scripts.

Test your mist.io installation with Cloudify as a service.

Here you could start with https://github.com/mistio/mist-cloudify-example where you need the Cloudify plugin https://github.com/mistio/cloudify-mist-plugin which allows you to deploy cloudify throught mist.io

Read More